
// Generated from CPP14Parser.g4 by ANTLR 4.11.1


#include "CPP14ParserVisitor.h"

#include "CPP14Parser.h"


using namespace antlrcpp;

using namespace antlr4;

namespace {

struct CPP14ParserStaticData final {
  CPP14ParserStaticData(std::vector<std::string> ruleNames,
                        std::vector<std::string> literalNames,
                        std::vector<std::string> symbolicNames)
      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
        symbolicNames(std::move(symbolicNames)),
        vocabulary(this->literalNames, this->symbolicNames) {}

  CPP14ParserStaticData(const CPP14ParserStaticData&) = delete;
  CPP14ParserStaticData(CPP14ParserStaticData&&) = delete;
  CPP14ParserStaticData& operator=(const CPP14ParserStaticData&) = delete;
  CPP14ParserStaticData& operator=(CPP14ParserStaticData&&) = delete;

  std::vector<antlr4::dfa::DFA> decisionToDFA;
  antlr4::atn::PredictionContextCache sharedContextCache;
  const std::vector<std::string> ruleNames;
  const std::vector<std::string> literalNames;
  const std::vector<std::string> symbolicNames;
  const antlr4::dfa::Vocabulary vocabulary;
  antlr4::atn::SerializedATNView serializedATN;
  std::unique_ptr<antlr4::atn::ATN> atn;
};

::antlr4::internal::OnceFlag cpp14parserParserOnceFlag;
CPP14ParserStaticData *cpp14parserParserStaticData = nullptr;

void cpp14parserParserInitialize() {
  assert(cpp14parserParserStaticData == nullptr);
  auto staticData = std::make_unique<CPP14ParserStaticData>(
    std::vector<std::string>{
      "translationUnit", "primaryExpression", "idExpression", "unqualifiedId", 
      "qualifiedId", "nestedNameSpecifier", "lambdaExpression", "lambdaIntroducer", 
      "lambdaCapture", "captureDefault", "captureList", "capture", "simpleCapture", 
      "initcapture", "lambdaDeclarator", "postfixExpression", "typeIdOfTheTypeId", 
      "expressionList", "pseudoDestructorName", "unaryExpression", "unaryOperator", 
      "newExpression", "newPlacement", "newTypeId", "newDeclarator", "noPointerNewDeclarator", 
      "newInitializer", "deleteExpression", "noExceptExpression", "castExpression", 
      "pointerMemberExpression", "multiplicativeExpression", "additiveExpression", 
      "shiftExpression", "shiftOperator", "relationalExpression", "equalityExpression", 
      "andExpression", "exclusiveOrExpression", "inclusiveOrExpression", 
      "logicalAndExpression", "logicalOrExpression", "conditionalExpression", 
      "assignmentExpression", "assignmentOperator", "expression", "constantExpression", 
      "statement", "labeledStatement", "expressionStatement", "compoundStatement", 
      "statementSeq", "selectionStatement", "condition", "iterationStatement", 
      "forInitStatement", "forRangeDeclaration", "forRangeInitializer", 
      "jumpStatement", "declarationStatement", "declarationseq", "declaration", 
      "blockDeclaration", "aliasDeclaration", "simpleDeclaration", "staticAssertDeclaration", 
      "emptyDeclaration", "attributeDeclaration", "declSpecifier", "declSpecifierSeq", 
      "storageClassSpecifier", "functionSpecifier", "typedefName", "typeSpecifier", 
      "trailingTypeSpecifier", "typeSpecifierSeq", "trailingTypeSpecifierSeq", 
      "simpleTypeLengthModifier", "simpleTypeSignednessModifier", "simpleTypeSpecifier", 
      "theTypeName", "decltypeSpecifier", "elaboratedTypeSpecifier", "enumName", 
      "enumSpecifier", "enumHead", "opaqueEnumDeclaration", "enumkey", "enumbase", 
      "enumeratorList", "enumeratorDefinition", "enumerator", "namespaceName", 
      "originalNamespaceName", "namespaceDefinition", "namespaceAlias", 
      "namespaceAliasDefinition", "qualifiednamespacespecifier", "usingDeclaration", 
      "usingDirective", "asmDefinition", "linkageSpecification", "attributeSpecifierSeq", 
      "attributeSpecifier", "alignmentspecifier", "attributeList", "attribute", 
      "attributeNamespace", "attributeArgumentClause", "balancedTokenSeq", 
      "balancedtoken", "initDeclaratorList", "initDeclarator", "declarator", 
      "pointerDeclarator", "noPointerDeclarator", "parametersAndQualifiers", 
      "trailingReturnType", "pointerOperator", "cvqualifierseq", "cvQualifier", 
      "refqualifier", "declaratorid", "theTypeId", "abstractDeclarator", 
      "pointerAbstractDeclarator", "noPointerAbstractDeclarator", "abstractPackDeclarator", 
      "noPointerAbstractPackDeclarator", "parameterDeclarationClause", "parameterDeclarationList", 
      "parameterDeclaration", "functionDefinition", "functionBody", "initializer", 
      "braceOrEqualInitializer", "initializerClause", "initializerList", 
      "bracedInitList", "className", "classSpecifier", "classHead", "classHeadName", 
      "classVirtSpecifier", "classKey", "memberSpecification", "memberdeclaration", 
      "memberDeclaratorList", "memberDeclarator", "virtualSpecifierSeq", 
      "virtualSpecifier", "pureSpecifier", "baseClause", "baseSpecifierList", 
      "baseSpecifier", "classOrDeclType", "baseTypeSpecifier", "accessSpecifier", 
      "conversionFunctionId", "conversionTypeId", "conversionDeclarator", 
      "constructorInitializer", "memInitializerList", "memInitializer", 
      "meminitializerid", "operatorFunctionId", "literalOperatorId", "templateDeclaration", 
      "templateparameterList", "templateParameter", "typeParameter", "simpleTemplateId", 
      "templateId", "templateName", "templateArgumentList", "templateArgument", 
      "typeNameSpecifier", "explicitInstantiation", "explicitSpecialization", 
      "tryBlock", "functionTryBlock", "handlerSeq", "handler", "exceptionDeclaration", 
      "throwExpression", "exceptionSpecification", "dynamicExceptionSpecification", 
      "typeIdList", "noeExceptSpecification", "theOperator", "literal"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "", "", "", "", "'alignas'", "'alignof'", 
      "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", "'char'", 
      "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", "'const_cast'", 
      "'continue'", "'decltype'", "'default'", "'delete'", "'do'", "'double'", 
      "'dynamic_cast'", "'else'", "'enum'", "'explicit'", "'export'", "'extern'", 
      "'false'", "'final'", "'float'", "'for'", "'friend'", "'goto'", "'if'", 
      "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", "'new'", 
      "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", 
      "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", 
      "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", 
      "'static_cast'", "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", 
      "'throw'", "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", 
      "'union'", "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", 
      "'wchar_t'", "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", 
      "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", "", 
      "'='", "'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", 
      "'&='", "'|='", "'<<='", "'>>='", "'=='", "'!='", "'<='", "'>='", 
      "", "", "'++'", "'--'", "','", "'->*'", "'->'", "'\\u003F'", "':'", 
      "'::'", "';'", "'.'", "'.*'", "'...'"
    },
    std::vector<std::string>{
      "", "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", 
      "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", 
      "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", 
      "Case", "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", 
      "Const_cast", "Continue", "Decltype", "Default", "Delete", "Do", "Double", 
      "Dynamic_cast", "Else", "Enum", "Explicit", "Export", "Extern", "False_", 
      "Final", "Float", "For", "Friend", "Goto", "If", "Inline", "Int", 
      "Long", "Mutable", "Namespace", "New", "Noexcept", "Nullptr", "Operator", 
      "Override", "Private", "Protected", "Public", "Register", "Reinterpret_cast", 
      "Return", "Short", "Signed", "Sizeof", "Static", "Static_assert", 
      "Static_cast", "Struct", "Switch", "Template", "This", "Thread_local", 
      "Throw", "True_", "Try", "Typedef", "Typeid_", "Typename_", "Union", 
      "Unsigned", "Using", "Virtual", "Void", "Volatile", "Wchar", "While", 
      "LeftParen", "RightParen", "LeftBracket", "RightBracket", "LeftBrace", 
      "RightBrace", "Plus", "Minus", "Star", "Div", "Mod", "Caret", "And", 
      "Or", "Tilde", "Not", "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", 
      "StarAssign", "DivAssign", "ModAssign", "XorAssign", "AndAssign", 
      "OrAssign", "LeftShiftAssign", "RightShiftAssign", "Equal", "NotEqual", 
      "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", "MinusMinus", 
      "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", 
      "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", 
      "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", 
      "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", 
      "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", 
      "LineComment", "ENTER"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,146,2110,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
  	2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
  	7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
  	7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
  	7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
  	7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
  	7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
  	7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
  	7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
  	7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
  	7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
  	7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
  	7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
  	7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,
  	7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,
  	7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,
  	7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,
  	7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,
  	7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,
  	7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,
  	7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
  	7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,
  	7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176,
  	7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,2,182,
  	7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,7,186,2,187,7,187,2,188,
  	7,188,2,189,7,189,2,190,7,190,1,0,3,0,384,8,0,1,0,1,0,1,1,4,1,389,8,1,
  	11,1,12,1,390,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,400,8,1,1,2,1,2,3,2,404,
  	8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,413,8,3,1,3,3,3,416,8,3,1,4,1,4,3,
  	4,420,8,4,1,4,1,4,1,5,1,5,1,5,1,5,3,5,428,8,5,1,5,1,5,1,5,1,5,1,5,3,5,
  	435,8,5,1,5,3,5,438,8,5,1,5,5,5,441,8,5,10,5,12,5,444,9,5,1,6,1,6,3,6,
  	448,8,6,1,6,1,6,1,7,1,7,3,7,454,8,7,1,7,1,7,1,8,1,8,1,8,1,8,3,8,462,8,
  	8,3,8,464,8,8,1,9,1,9,1,10,1,10,1,10,5,10,471,8,10,10,10,12,10,474,9,
  	10,1,10,3,10,477,8,10,1,11,1,11,3,11,481,8,11,1,12,3,12,484,8,12,1,12,
  	1,12,3,12,488,8,12,1,13,3,13,491,8,13,1,13,1,13,1,13,1,14,1,14,3,14,498,
  	8,14,1,14,1,14,3,14,502,8,14,1,14,3,14,505,8,14,1,14,3,14,508,8,14,1,
  	14,3,14,511,8,14,1,15,1,15,1,15,1,15,3,15,517,8,15,1,15,1,15,3,15,521,
  	8,15,1,15,1,15,3,15,525,8,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,
  	1,15,1,15,1,15,1,15,3,15,539,8,15,1,15,1,15,3,15,543,8,15,1,15,1,15,1,
  	15,1,15,3,15,549,8,15,1,15,1,15,1,15,1,15,1,15,3,15,556,8,15,1,15,1,15,
  	1,15,1,15,3,15,562,8,15,1,15,1,15,3,15,566,8,15,1,15,1,15,5,15,570,8,
  	15,10,15,12,15,573,9,15,1,16,1,16,1,17,1,17,1,18,3,18,580,8,18,1,18,1,
  	18,1,18,3,18,585,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,
  	18,1,18,3,18,598,8,18,1,19,1,19,1,19,1,19,1,19,3,19,605,8,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,3,19,617,8,19,1,19,1,19,1,19,
  	1,19,1,19,1,19,1,19,1,19,3,19,627,8,19,1,20,1,20,1,21,3,21,632,8,21,1,
  	21,1,21,3,21,636,8,21,1,21,1,21,1,21,1,21,1,21,3,21,643,8,21,1,21,3,21,
  	646,8,21,1,22,1,22,1,22,1,22,1,23,1,23,3,23,654,8,23,1,24,1,24,3,24,658,
  	8,24,1,24,3,24,661,8,24,1,25,1,25,1,25,1,25,1,25,3,25,668,8,25,1,25,1,
  	25,1,25,1,25,1,25,3,25,675,8,25,5,25,677,8,25,10,25,12,25,680,9,25,1,
  	26,1,26,3,26,684,8,26,1,26,1,26,3,26,688,8,26,1,27,3,27,691,8,27,1,27,
  	1,27,1,27,3,27,696,8,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,29,1,29,
  	1,29,1,29,1,29,1,29,3,29,711,8,29,1,30,1,30,1,30,5,30,716,8,30,10,30,
  	12,30,719,9,30,1,31,1,31,1,31,5,31,724,8,31,10,31,12,31,727,9,31,1,32,
  	1,32,1,32,5,32,732,8,32,10,32,12,32,735,9,32,1,33,1,33,1,33,1,33,5,33,
  	741,8,33,10,33,12,33,744,9,33,1,34,1,34,1,34,1,34,3,34,750,8,34,1,35,
  	1,35,1,35,5,35,755,8,35,10,35,12,35,758,9,35,1,36,1,36,1,36,5,36,763,
  	8,36,10,36,12,36,766,9,36,1,37,1,37,1,37,5,37,771,8,37,10,37,12,37,774,
  	9,37,1,38,1,38,1,38,5,38,779,8,38,10,38,12,38,782,9,38,1,39,1,39,1,39,
  	5,39,787,8,39,10,39,12,39,790,9,39,1,40,1,40,1,40,5,40,795,8,40,10,40,
  	12,40,798,9,40,1,41,1,41,1,41,5,41,803,8,41,10,41,12,41,806,9,41,1,42,
  	1,42,1,42,1,42,1,42,1,42,3,42,814,8,42,1,43,1,43,1,43,1,43,1,43,1,43,
  	3,43,822,8,43,1,44,1,44,1,45,1,45,1,45,5,45,829,8,45,10,45,12,45,832,
  	9,45,1,46,1,46,1,47,1,47,1,47,3,47,839,8,47,1,47,1,47,1,47,1,47,1,47,
  	1,47,3,47,847,8,47,3,47,849,8,47,1,48,3,48,852,8,48,1,48,1,48,1,48,1,
  	48,3,48,858,8,48,1,48,1,48,1,48,1,49,3,49,864,8,49,1,49,1,49,1,50,1,50,
  	3,50,870,8,50,1,50,1,50,1,51,4,51,875,8,51,11,51,12,51,876,1,52,1,52,
  	1,52,1,52,1,52,1,52,1,52,3,52,886,8,52,1,52,1,52,1,52,1,52,1,52,1,52,
  	3,52,894,8,52,1,53,1,53,3,53,898,8,53,1,53,1,53,1,53,1,53,1,53,3,53,905,
  	8,53,3,53,907,8,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,
  	1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,3,54,927,8,54,1,54,1,54,3,54,
  	931,8,54,1,54,1,54,1,54,1,54,3,54,937,8,54,1,54,1,54,1,54,3,54,942,8,
  	54,1,55,1,55,3,55,946,8,55,1,56,3,56,949,8,56,1,56,1,56,1,56,1,57,1,57,
  	3,57,956,8,57,1,58,1,58,1,58,1,58,1,58,3,58,963,8,58,1,58,1,58,3,58,967,
  	8,58,1,58,1,58,1,59,1,59,1,60,4,60,974,8,60,11,60,12,60,975,1,61,1,61,
  	1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,987,8,61,1,62,1,62,1,62,1,62,
  	1,62,1,62,1,62,1,62,3,62,997,8,62,1,63,1,63,1,63,3,63,1002,8,63,1,63,
  	1,63,1,63,1,63,1,64,3,64,1009,8,64,1,64,3,64,1012,8,64,1,64,1,64,1,64,
  	3,64,1017,8,64,1,64,1,64,1,64,3,64,1022,8,64,1,65,1,65,1,65,1,65,1,65,
  	1,65,1,65,1,65,1,66,1,66,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68,
  	3,68,1043,8,68,1,69,4,69,1046,8,69,11,69,12,69,1047,1,69,3,69,1051,8,
  	69,1,70,1,70,1,71,1,71,1,72,1,72,1,73,1,73,1,73,3,73,1062,8,73,1,74,1,
  	74,1,74,1,74,3,74,1068,8,74,1,75,4,75,1071,8,75,11,75,12,75,1072,1,75,
  	3,75,1076,8,75,1,76,4,76,1079,8,76,11,76,12,76,1080,1,76,3,76,1084,8,
  	76,1,77,1,77,1,78,1,78,1,79,3,79,1091,8,79,1,79,1,79,1,79,1,79,1,79,1,
  	79,1,79,3,79,1100,8,79,1,79,4,79,1103,8,79,11,79,12,79,1104,1,79,3,79,
  	1108,8,79,1,79,1,79,3,79,1112,8,79,1,79,1,79,3,79,1116,8,79,1,79,1,79,
  	3,79,1120,8,79,1,79,1,79,1,79,3,79,1125,8,79,1,79,5,79,1128,8,79,10,79,
  	12,79,1131,9,79,1,79,1,79,1,79,3,79,1136,8,79,1,79,1,79,1,79,1,79,3,79,
  	1142,8,79,1,80,1,80,1,80,1,80,3,80,1148,8,80,1,81,1,81,1,81,1,81,3,81,
  	1154,8,81,1,81,1,81,1,82,1,82,3,82,1160,8,82,1,82,3,82,1163,8,82,1,82,
  	1,82,1,82,1,82,3,82,1169,8,82,1,82,1,82,3,82,1173,8,82,1,82,1,82,3,82,
  	1177,8,82,1,82,3,82,1180,8,82,1,83,1,83,1,84,1,84,1,84,1,84,3,84,1188,
  	8,84,3,84,1190,8,84,1,84,1,84,1,85,1,85,3,85,1196,8,85,1,85,3,85,1199,
  	8,85,1,85,3,85,1202,8,85,1,85,3,85,1205,8,85,1,86,1,86,3,86,1209,8,86,
  	1,86,1,86,3,86,1213,8,86,1,86,1,86,1,87,1,87,3,87,1219,8,87,1,88,1,88,
  	1,88,1,89,1,89,1,89,5,89,1227,8,89,10,89,12,89,1230,9,89,1,90,1,90,1,
  	90,3,90,1235,8,90,1,91,1,91,1,92,1,92,3,92,1241,8,92,1,93,1,93,1,94,3,
  	94,1246,8,94,1,94,1,94,1,94,3,94,1251,8,94,1,94,1,94,3,94,1255,8,94,1,
  	94,1,94,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,97,3,97,1268,8,97,1,
  	97,1,97,1,98,1,98,3,98,1274,8,98,1,98,1,98,3,98,1278,8,98,1,98,1,98,1,
  	98,1,99,3,99,1284,8,99,1,99,1,99,1,99,3,99,1289,8,99,1,99,1,99,1,99,1,
  	100,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,3,101,1304,
  	8,101,1,101,1,101,3,101,1308,8,101,1,102,4,102,1311,8,102,11,102,12,102,
  	1312,1,103,1,103,1,103,3,103,1318,8,103,1,103,1,103,1,103,3,103,1323,
  	8,103,1,104,1,104,1,104,1,104,3,104,1329,8,104,1,104,3,104,1332,8,104,
  	1,104,1,104,1,105,1,105,1,105,5,105,1339,8,105,10,105,12,105,1342,9,105,
  	1,105,3,105,1345,8,105,1,106,1,106,1,106,3,106,1350,8,106,1,106,1,106,
  	3,106,1354,8,106,1,107,1,107,1,108,1,108,3,108,1360,8,108,1,108,1,108,
  	1,109,4,109,1365,8,109,11,109,12,109,1366,1,110,1,110,1,110,1,110,1,110,
  	1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,4,110,1382,8,110,11,110,
  	12,110,1383,3,110,1386,8,110,1,111,1,111,1,111,5,111,1391,8,111,10,111,
  	12,111,1394,9,111,1,112,1,112,3,112,1398,8,112,1,113,1,113,1,113,1,113,
  	1,113,3,113,1405,8,113,1,114,1,114,3,114,1409,8,114,5,114,1411,8,114,
  	10,114,12,114,1414,9,114,1,114,1,114,1,115,1,115,1,115,3,115,1421,8,115,
  	1,115,1,115,1,115,1,115,3,115,1427,8,115,1,115,1,115,1,115,1,115,3,115,
  	1433,8,115,1,115,1,115,3,115,1437,8,115,3,115,1439,8,115,5,115,1441,8,
  	115,10,115,12,115,1444,9,115,1,116,1,116,3,116,1448,8,116,1,116,1,116,
  	3,116,1452,8,116,1,116,3,116,1455,8,116,1,116,3,116,1458,8,116,1,116,
  	3,116,1461,8,116,1,117,1,117,1,117,3,117,1466,8,117,1,118,1,118,3,118,
  	1470,8,118,1,118,3,118,1473,8,118,1,118,1,118,3,118,1477,8,118,1,118,
  	3,118,1480,8,118,3,118,1482,8,118,1,119,4,119,1485,8,119,11,119,12,119,
  	1486,1,120,1,120,1,121,1,121,1,122,3,122,1494,8,122,1,122,1,122,1,123,
  	1,123,3,123,1500,8,123,1,124,1,124,3,124,1504,8,124,1,124,1,124,1,124,
  	1,124,3,124,1510,8,124,1,125,1,125,4,125,1514,8,125,11,125,12,125,1515,
  	1,125,3,125,1519,8,125,3,125,1521,8,125,1,126,1,126,1,126,1,126,3,126,
  	1527,8,126,1,126,1,126,3,126,1531,8,126,1,126,1,126,1,126,1,126,3,126,
  	1537,8,126,1,126,1,126,1,126,1,126,1,126,3,126,1544,8,126,1,126,1,126,
  	3,126,1548,8,126,3,126,1550,8,126,5,126,1552,8,126,10,126,12,126,1555,
  	9,126,1,127,5,127,1558,8,127,10,127,12,127,1561,9,127,1,127,1,127,1,128,
  	1,128,1,128,1,128,1,128,1,128,1,128,3,128,1572,8,128,1,128,1,128,3,128,
  	1576,8,128,3,128,1578,8,128,5,128,1580,8,128,10,128,12,128,1583,9,128,
  	1,129,1,129,3,129,1587,8,129,1,129,3,129,1590,8,129,1,130,1,130,1,130,
  	5,130,1595,8,130,10,130,12,130,1598,9,130,1,131,3,131,1601,8,131,1,131,
  	1,131,1,131,3,131,1606,8,131,3,131,1608,8,131,1,131,1,131,3,131,1612,
  	8,131,1,132,3,132,1615,8,132,1,132,3,132,1618,8,132,1,132,1,132,3,132,
  	1622,8,132,1,132,1,132,1,133,3,133,1627,8,133,1,133,1,133,1,133,1,133,
  	1,133,3,133,1634,8,133,1,134,1,134,1,134,1,134,1,134,3,134,1641,8,134,
  	1,135,1,135,1,135,3,135,1646,8,135,1,136,1,136,3,136,1650,8,136,1,137,
  	1,137,3,137,1654,8,137,1,137,1,137,1,137,3,137,1659,8,137,5,137,1661,
  	8,137,10,137,12,137,1664,9,137,1,138,1,138,1,138,3,138,1669,8,138,3,138,
  	1671,8,138,1,138,1,138,1,139,1,139,3,139,1677,8,139,1,140,1,140,1,140,
  	3,140,1682,8,140,1,140,1,140,1,141,1,141,3,141,1688,8,141,1,141,1,141,
  	3,141,1692,8,141,3,141,1694,8,141,1,141,3,141,1697,8,141,1,141,1,141,
  	3,141,1701,8,141,1,141,1,141,3,141,1705,8,141,3,141,1707,8,141,3,141,
  	1709,8,141,1,142,3,142,1712,8,142,1,142,1,142,1,143,1,143,1,144,1,144,
  	1,145,1,145,1,145,1,145,4,145,1724,8,145,11,145,12,145,1725,1,146,3,146,
  	1729,8,146,1,146,3,146,1732,8,146,1,146,3,146,1735,8,146,1,146,1,146,
  	1,146,1,146,1,146,1,146,1,146,3,146,1744,8,146,1,147,1,147,1,147,5,147,
  	1749,8,147,10,147,12,147,1752,9,147,1,148,1,148,3,148,1756,8,148,1,148,
  	3,148,1759,8,148,1,148,3,148,1762,8,148,3,148,1764,8,148,1,148,3,148,
  	1767,8,148,1,148,3,148,1770,8,148,1,148,1,148,3,148,1774,8,148,1,149,
  	4,149,1777,8,149,11,149,12,149,1778,1,150,1,150,1,151,1,151,1,151,1,151,
  	1,152,1,152,1,152,1,153,1,153,3,153,1792,8,153,1,153,1,153,1,153,3,153,
  	1797,8,153,5,153,1799,8,153,10,153,12,153,1802,9,153,1,154,3,154,1805,
  	8,154,1,154,1,154,1,154,3,154,1810,8,154,1,154,1,154,1,154,3,154,1815,
  	8,154,1,154,1,154,3,154,1819,8,154,1,155,3,155,1822,8,155,1,155,1,155,
  	3,155,1826,8,155,1,156,1,156,1,157,1,157,1,158,1,158,1,158,1,159,1,159,
  	3,159,1837,8,159,1,160,1,160,3,160,1841,8,160,1,161,1,161,1,161,1,162,
  	1,162,3,162,1848,8,162,1,162,1,162,1,162,3,162,1853,8,162,5,162,1855,
  	8,162,10,162,12,162,1858,9,162,1,163,1,163,1,163,3,163,1863,8,163,1,163,
  	1,163,3,163,1867,8,163,1,164,1,164,3,164,1871,8,164,1,165,1,165,1,165,
  	1,166,1,166,1,166,1,166,3,166,1880,8,166,1,167,1,167,1,167,1,167,1,167,
  	1,167,1,168,1,168,1,168,5,168,1891,8,168,10,168,12,168,1894,9,168,1,169,
  	1,169,3,169,1898,8,169,1,170,1,170,1,170,1,170,1,170,3,170,1905,8,170,
  	1,170,1,170,3,170,1909,8,170,1,170,3,170,1912,8,170,1,170,3,170,1915,
  	8,170,1,170,3,170,1918,8,170,1,170,1,170,3,170,1922,8,170,1,171,1,171,
  	1,171,3,171,1927,8,171,1,171,1,171,1,172,1,172,1,172,3,172,1934,8,172,
  	1,172,1,172,3,172,1938,8,172,1,172,1,172,3,172,1942,8,172,1,173,1,173,
  	1,174,1,174,3,174,1948,8,174,1,174,1,174,1,174,3,174,1953,8,174,5,174,
  	1955,8,174,10,174,12,174,1958,9,174,1,175,1,175,1,175,3,175,1963,8,175,
  	1,176,1,176,1,176,1,176,3,176,1969,8,176,1,176,3,176,1972,8,176,1,177,
  	3,177,1975,8,177,1,177,1,177,1,177,1,178,1,178,1,178,1,178,1,178,1,179,
  	1,179,1,179,1,179,1,180,1,180,3,180,1991,8,180,1,180,1,180,1,180,1,181,
  	4,181,1997,8,181,11,181,12,181,1998,1,182,1,182,1,182,1,182,1,182,1,182,
  	1,183,3,183,2008,8,183,1,183,1,183,1,183,3,183,2013,8,183,1,183,3,183,
  	2016,8,183,1,184,1,184,3,184,2020,8,184,1,185,1,185,3,185,2024,8,185,
  	1,186,1,186,1,186,3,186,2029,8,186,1,186,1,186,1,187,1,187,3,187,2035,
  	8,187,1,187,1,187,1,187,3,187,2040,8,187,5,187,2042,8,187,10,187,12,187,
  	2045,9,187,1,188,1,188,1,188,1,188,1,188,1,188,3,188,2053,8,188,1,189,
  	1,189,1,189,3,189,2058,8,189,1,189,1,189,1,189,3,189,2063,8,189,1,189,
  	1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
  	1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
  	1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,1,189,
  	1,189,1,189,1,189,1,189,3,189,2106,8,189,1,190,1,190,1,190,1,1047,6,10,
  	30,50,230,252,256,191,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,
  	36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,
  	82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,
  	122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,
  	158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,
  	194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,
  	230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,
  	266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,
  	302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,
  	338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,372,
  	374,376,378,380,0,23,2,0,97,97,101,101,4,0,24,24,31,31,58,58,65,65,2,
  	0,124,124,129,129,1,0,120,121,2,0,91,93,97,100,2,0,123,123,130,130,1,
  	0,93,95,1,0,91,92,2,0,102,103,116,117,1,0,114,115,2,0,101,101,104,113,
  	5,0,36,36,47,47,57,57,63,63,70,70,3,0,34,34,44,44,80,80,2,0,46,46,60,
  	60,2,0,61,61,78,78,2,0,21,21,66,66,1,0,85,90,2,0,97,97,118,118,2,0,22,
  	22,82,82,1,0,27,28,2,0,38,38,53,53,1,0,54,56,1,0,1,7,2343,0,383,1,0,0,
  	0,2,399,1,0,0,0,4,403,1,0,0,0,6,415,1,0,0,0,8,417,1,0,0,0,10,423,1,0,
  	0,0,12,445,1,0,0,0,14,451,1,0,0,0,16,463,1,0,0,0,18,465,1,0,0,0,20,467,
  	1,0,0,0,22,480,1,0,0,0,24,487,1,0,0,0,26,490,1,0,0,0,28,495,1,0,0,0,30,
  	542,1,0,0,0,32,574,1,0,0,0,34,576,1,0,0,0,36,597,1,0,0,0,38,626,1,0,0,
  	0,40,628,1,0,0,0,42,631,1,0,0,0,44,647,1,0,0,0,46,651,1,0,0,0,48,660,
  	1,0,0,0,50,662,1,0,0,0,52,687,1,0,0,0,54,690,1,0,0,0,56,699,1,0,0,0,58,
  	710,1,0,0,0,60,712,1,0,0,0,62,720,1,0,0,0,64,728,1,0,0,0,66,736,1,0,0,
  	0,68,749,1,0,0,0,70,751,1,0,0,0,72,759,1,0,0,0,74,767,1,0,0,0,76,775,
  	1,0,0,0,78,783,1,0,0,0,80,791,1,0,0,0,82,799,1,0,0,0,84,807,1,0,0,0,86,
  	821,1,0,0,0,88,823,1,0,0,0,90,825,1,0,0,0,92,833,1,0,0,0,94,848,1,0,0,
  	0,96,851,1,0,0,0,98,863,1,0,0,0,100,867,1,0,0,0,102,874,1,0,0,0,104,893,
  	1,0,0,0,106,906,1,0,0,0,108,941,1,0,0,0,110,945,1,0,0,0,112,948,1,0,0,
  	0,114,955,1,0,0,0,116,966,1,0,0,0,118,970,1,0,0,0,120,973,1,0,0,0,122,
  	986,1,0,0,0,124,996,1,0,0,0,126,998,1,0,0,0,128,1021,1,0,0,0,130,1023,
  	1,0,0,0,132,1031,1,0,0,0,134,1033,1,0,0,0,136,1042,1,0,0,0,138,1045,1,
  	0,0,0,140,1052,1,0,0,0,142,1054,1,0,0,0,144,1056,1,0,0,0,146,1061,1,0,
  	0,0,148,1067,1,0,0,0,150,1070,1,0,0,0,152,1078,1,0,0,0,154,1085,1,0,0,
  	0,156,1087,1,0,0,0,158,1141,1,0,0,0,160,1147,1,0,0,0,162,1149,1,0,0,0,
  	164,1179,1,0,0,0,166,1181,1,0,0,0,168,1183,1,0,0,0,170,1193,1,0,0,0,172,
  	1206,1,0,0,0,174,1216,1,0,0,0,176,1220,1,0,0,0,178,1223,1,0,0,0,180,1231,
  	1,0,0,0,182,1236,1,0,0,0,184,1240,1,0,0,0,186,1242,1,0,0,0,188,1245,1,
  	0,0,0,190,1258,1,0,0,0,192,1260,1,0,0,0,194,1267,1,0,0,0,196,1271,1,0,
  	0,0,198,1283,1,0,0,0,200,1293,1,0,0,0,202,1299,1,0,0,0,204,1310,1,0,0,
  	0,206,1322,1,0,0,0,208,1324,1,0,0,0,210,1335,1,0,0,0,212,1349,1,0,0,0,
  	214,1355,1,0,0,0,216,1357,1,0,0,0,218,1364,1,0,0,0,220,1385,1,0,0,0,222,
  	1387,1,0,0,0,224,1395,1,0,0,0,226,1404,1,0,0,0,228,1412,1,0,0,0,230,1426,
  	1,0,0,0,232,1445,1,0,0,0,234,1462,1,0,0,0,236,1481,1,0,0,0,238,1484,1,
  	0,0,0,240,1488,1,0,0,0,242,1490,1,0,0,0,244,1493,1,0,0,0,246,1497,1,0,
  	0,0,248,1509,1,0,0,0,250,1520,1,0,0,0,252,1536,1,0,0,0,254,1559,1,0,0,
  	0,256,1564,1,0,0,0,258,1584,1,0,0,0,260,1591,1,0,0,0,262,1600,1,0,0,0,
  	264,1614,1,0,0,0,266,1633,1,0,0,0,268,1640,1,0,0,0,270,1645,1,0,0,0,272,
  	1649,1,0,0,0,274,1651,1,0,0,0,276,1665,1,0,0,0,278,1676,1,0,0,0,280,1678,
  	1,0,0,0,282,1708,1,0,0,0,284,1711,1,0,0,0,286,1715,1,0,0,0,288,1717,1,
  	0,0,0,290,1723,1,0,0,0,292,1743,1,0,0,0,294,1745,1,0,0,0,296,1773,1,0,
  	0,0,298,1776,1,0,0,0,300,1780,1,0,0,0,302,1782,1,0,0,0,304,1786,1,0,0,
  	0,306,1789,1,0,0,0,308,1804,1,0,0,0,310,1825,1,0,0,0,312,1827,1,0,0,0,
  	314,1829,1,0,0,0,316,1831,1,0,0,0,318,1834,1,0,0,0,320,1838,1,0,0,0,322,
  	1842,1,0,0,0,324,1845,1,0,0,0,326,1859,1,0,0,0,328,1870,1,0,0,0,330,1872,
  	1,0,0,0,332,1875,1,0,0,0,334,1881,1,0,0,0,336,1887,1,0,0,0,338,1897,1,
  	0,0,0,340,1908,1,0,0,0,342,1923,1,0,0,0,344,1941,1,0,0,0,346,1943,1,0,
  	0,0,348,1945,1,0,0,0,350,1962,1,0,0,0,352,1964,1,0,0,0,354,1974,1,0,0,
  	0,356,1979,1,0,0,0,358,1984,1,0,0,0,360,1988,1,0,0,0,362,1996,1,0,0,0,
  	364,2000,1,0,0,0,366,2015,1,0,0,0,368,2017,1,0,0,0,370,2023,1,0,0,0,372,
  	2025,1,0,0,0,374,2032,1,0,0,0,376,2052,1,0,0,0,378,2105,1,0,0,0,380,2107,
  	1,0,0,0,382,384,3,120,60,0,383,382,1,0,0,0,383,384,1,0,0,0,384,385,1,
  	0,0,0,385,386,5,0,0,1,386,1,1,0,0,0,387,389,3,380,190,0,388,387,1,0,0,
  	0,389,390,1,0,0,0,390,388,1,0,0,0,390,391,1,0,0,0,391,400,1,0,0,0,392,
  	400,5,69,0,0,393,394,5,85,0,0,394,395,3,90,45,0,395,396,5,86,0,0,396,
  	400,1,0,0,0,397,400,3,4,2,0,398,400,3,12,6,0,399,388,1,0,0,0,399,392,
  	1,0,0,0,399,393,1,0,0,0,399,397,1,0,0,0,399,398,1,0,0,0,400,3,1,0,0,0,
  	401,404,3,6,3,0,402,404,3,8,4,0,403,401,1,0,0,0,403,402,1,0,0,0,404,5,
  	1,0,0,0,405,416,5,132,0,0,406,416,3,330,165,0,407,416,3,316,158,0,408,
  	416,3,332,166,0,409,412,5,99,0,0,410,413,3,278,139,0,411,413,3,162,81,
  	0,412,410,1,0,0,0,412,411,1,0,0,0,413,416,1,0,0,0,414,416,3,344,172,0,
  	415,405,1,0,0,0,415,406,1,0,0,0,415,407,1,0,0,0,415,408,1,0,0,0,415,409,
  	1,0,0,0,415,414,1,0,0,0,416,7,1,0,0,0,417,419,3,10,5,0,418,420,5,68,0,
  	0,419,418,1,0,0,0,419,420,1,0,0,0,420,421,1,0,0,0,421,422,3,6,3,0,422,
  	9,1,0,0,0,423,427,6,5,-1,0,424,428,3,160,80,0,425,428,3,184,92,0,426,
  	428,3,162,81,0,427,424,1,0,0,0,427,425,1,0,0,0,427,426,1,0,0,0,427,428,
  	1,0,0,0,428,429,1,0,0,0,429,430,5,127,0,0,430,442,1,0,0,0,431,437,10,
  	1,0,0,432,438,5,132,0,0,433,435,5,68,0,0,434,433,1,0,0,0,434,435,1,0,
  	0,0,435,436,1,0,0,0,436,438,3,342,171,0,437,432,1,0,0,0,437,434,1,0,0,
  	0,438,439,1,0,0,0,439,441,5,127,0,0,440,431,1,0,0,0,441,444,1,0,0,0,442,
  	440,1,0,0,0,442,443,1,0,0,0,443,11,1,0,0,0,444,442,1,0,0,0,445,447,3,
  	14,7,0,446,448,3,28,14,0,447,446,1,0,0,0,447,448,1,0,0,0,448,449,1,0,
  	0,0,449,450,3,100,50,0,450,13,1,0,0,0,451,453,5,87,0,0,452,454,3,16,8,
  	0,453,452,1,0,0,0,453,454,1,0,0,0,454,455,1,0,0,0,455,456,5,88,0,0,456,
  	15,1,0,0,0,457,464,3,20,10,0,458,461,3,18,9,0,459,460,5,122,0,0,460,462,
  	3,20,10,0,461,459,1,0,0,0,461,462,1,0,0,0,462,464,1,0,0,0,463,457,1,0,
  	0,0,463,458,1,0,0,0,464,17,1,0,0,0,465,466,7,0,0,0,466,19,1,0,0,0,467,
  	472,3,22,11,0,468,469,5,122,0,0,469,471,3,22,11,0,470,468,1,0,0,0,471,
  	474,1,0,0,0,472,470,1,0,0,0,472,473,1,0,0,0,473,476,1,0,0,0,474,472,1,
  	0,0,0,475,477,5,131,0,0,476,475,1,0,0,0,476,477,1,0,0,0,477,21,1,0,0,
  	0,478,481,3,24,12,0,479,481,3,26,13,0,480,478,1,0,0,0,480,479,1,0,0,0,
  	481,23,1,0,0,0,482,484,5,97,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,485,
  	1,0,0,0,485,488,5,132,0,0,486,488,5,69,0,0,487,483,1,0,0,0,487,486,1,
  	0,0,0,488,25,1,0,0,0,489,491,5,97,0,0,490,489,1,0,0,0,490,491,1,0,0,0,
  	491,492,1,0,0,0,492,493,5,132,0,0,493,494,3,268,134,0,494,27,1,0,0,0,
  	495,497,5,85,0,0,496,498,3,258,129,0,497,496,1,0,0,0,497,498,1,0,0,0,
  	498,499,1,0,0,0,499,501,5,86,0,0,500,502,5,47,0,0,501,500,1,0,0,0,501,
  	502,1,0,0,0,502,504,1,0,0,0,503,505,3,370,185,0,504,503,1,0,0,0,504,505,
  	1,0,0,0,505,507,1,0,0,0,506,508,3,204,102,0,507,506,1,0,0,0,507,508,1,
  	0,0,0,508,510,1,0,0,0,509,511,3,234,117,0,510,509,1,0,0,0,510,511,1,0,
  	0,0,511,29,1,0,0,0,512,513,6,15,-1,0,513,543,3,2,1,0,514,517,3,158,79,
  	0,515,517,3,352,176,0,516,514,1,0,0,0,516,515,1,0,0,0,517,524,1,0,0,0,
  	518,520,5,85,0,0,519,521,3,34,17,0,520,519,1,0,0,0,520,521,1,0,0,0,521,
  	522,1,0,0,0,522,525,5,86,0,0,523,525,3,276,138,0,524,518,1,0,0,0,524,
  	523,1,0,0,0,525,543,1,0,0,0,526,527,7,1,0,0,527,528,5,102,0,0,528,529,
  	3,246,123,0,529,530,5,103,0,0,530,531,5,85,0,0,531,532,3,90,45,0,532,
  	533,5,86,0,0,533,543,1,0,0,0,534,535,3,32,16,0,535,538,5,85,0,0,536,539,
  	3,90,45,0,537,539,3,246,123,0,538,536,1,0,0,0,538,537,1,0,0,0,539,540,
  	1,0,0,0,540,541,5,86,0,0,541,543,1,0,0,0,542,512,1,0,0,0,542,516,1,0,
  	0,0,542,526,1,0,0,0,542,534,1,0,0,0,543,571,1,0,0,0,544,545,10,7,0,0,
  	545,548,5,87,0,0,546,549,3,90,45,0,547,549,3,276,138,0,548,546,1,0,0,
  	0,548,547,1,0,0,0,549,550,1,0,0,0,550,551,5,88,0,0,551,570,1,0,0,0,552,
  	553,10,6,0,0,553,555,5,85,0,0,554,556,3,34,17,0,555,554,1,0,0,0,555,556,
  	1,0,0,0,556,557,1,0,0,0,557,570,5,86,0,0,558,559,10,4,0,0,559,565,7,2,
  	0,0,560,562,5,68,0,0,561,560,1,0,0,0,561,562,1,0,0,0,562,563,1,0,0,0,
  	563,566,3,4,2,0,564,566,3,36,18,0,565,561,1,0,0,0,565,564,1,0,0,0,566,
  	570,1,0,0,0,567,568,10,3,0,0,568,570,7,3,0,0,569,544,1,0,0,0,569,552,
  	1,0,0,0,569,558,1,0,0,0,569,567,1,0,0,0,570,573,1,0,0,0,571,569,1,0,0,
  	0,571,572,1,0,0,0,572,31,1,0,0,0,573,571,1,0,0,0,574,575,5,75,0,0,575,
  	33,1,0,0,0,576,577,3,274,137,0,577,35,1,0,0,0,578,580,3,10,5,0,579,578,
  	1,0,0,0,579,580,1,0,0,0,580,584,1,0,0,0,581,582,3,160,80,0,582,583,5,
  	127,0,0,583,585,1,0,0,0,584,581,1,0,0,0,584,585,1,0,0,0,585,586,1,0,0,
  	0,586,587,5,99,0,0,587,598,3,160,80,0,588,589,3,10,5,0,589,590,5,68,0,
  	0,590,591,3,342,171,0,591,592,5,127,0,0,592,593,5,99,0,0,593,594,3,160,
  	80,0,594,598,1,0,0,0,595,596,5,99,0,0,596,598,3,162,81,0,597,579,1,0,
  	0,0,597,588,1,0,0,0,597,595,1,0,0,0,598,37,1,0,0,0,599,627,3,30,15,0,
  	600,605,5,120,0,0,601,605,5,121,0,0,602,605,3,40,20,0,603,605,5,62,0,
  	0,604,600,1,0,0,0,604,601,1,0,0,0,604,602,1,0,0,0,604,603,1,0,0,0,605,
  	606,1,0,0,0,606,627,3,38,19,0,607,616,5,62,0,0,608,609,5,85,0,0,609,610,
  	3,246,123,0,610,611,5,86,0,0,611,617,1,0,0,0,612,613,5,131,0,0,613,614,
  	5,85,0,0,614,615,5,132,0,0,615,617,5,86,0,0,616,608,1,0,0,0,616,612,1,
  	0,0,0,617,627,1,0,0,0,618,619,5,11,0,0,619,620,5,85,0,0,620,621,3,246,
  	123,0,621,622,5,86,0,0,622,627,1,0,0,0,623,627,3,56,28,0,624,627,3,42,
  	21,0,625,627,3,54,27,0,626,599,1,0,0,0,626,604,1,0,0,0,626,607,1,0,0,
  	0,626,618,1,0,0,0,626,623,1,0,0,0,626,624,1,0,0,0,626,625,1,0,0,0,627,
  	39,1,0,0,0,628,629,7,4,0,0,629,41,1,0,0,0,630,632,5,127,0,0,631,630,1,
  	0,0,0,631,632,1,0,0,0,632,633,1,0,0,0,633,635,5,49,0,0,634,636,3,44,22,
  	0,635,634,1,0,0,0,635,636,1,0,0,0,636,642,1,0,0,0,637,643,3,46,23,0,638,
  	639,5,85,0,0,639,640,3,246,123,0,640,641,5,86,0,0,641,643,1,0,0,0,642,
  	637,1,0,0,0,642,638,1,0,0,0,643,645,1,0,0,0,644,646,3,52,26,0,645,644,
  	1,0,0,0,645,646,1,0,0,0,646,43,1,0,0,0,647,648,5,85,0,0,648,649,3,34,
  	17,0,649,650,5,86,0,0,650,45,1,0,0,0,651,653,3,150,75,0,652,654,3,48,
  	24,0,653,652,1,0,0,0,653,654,1,0,0,0,654,47,1,0,0,0,655,657,3,236,118,
  	0,656,658,3,48,24,0,657,656,1,0,0,0,657,658,1,0,0,0,658,661,1,0,0,0,659,
  	661,3,50,25,0,660,655,1,0,0,0,660,659,1,0,0,0,661,49,1,0,0,0,662,663,
  	6,25,-1,0,663,664,5,87,0,0,664,665,3,90,45,0,665,667,5,88,0,0,666,668,
  	3,204,102,0,667,666,1,0,0,0,667,668,1,0,0,0,668,678,1,0,0,0,669,670,10,
  	1,0,0,670,671,5,87,0,0,671,672,3,92,46,0,672,674,5,88,0,0,673,675,3,204,
  	102,0,674,673,1,0,0,0,674,675,1,0,0,0,675,677,1,0,0,0,676,669,1,0,0,0,
  	677,680,1,0,0,0,678,676,1,0,0,0,678,679,1,0,0,0,679,51,1,0,0,0,680,678,
  	1,0,0,0,681,683,5,85,0,0,682,684,3,34,17,0,683,682,1,0,0,0,683,684,1,
  	0,0,0,684,685,1,0,0,0,685,688,5,86,0,0,686,688,3,276,138,0,687,681,1,
  	0,0,0,687,686,1,0,0,0,688,53,1,0,0,0,689,691,5,127,0,0,690,689,1,0,0,
  	0,690,691,1,0,0,0,691,692,1,0,0,0,692,695,5,28,0,0,693,694,5,87,0,0,694,
  	696,5,88,0,0,695,693,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,698,
  	3,58,29,0,698,55,1,0,0,0,699,700,5,50,0,0,700,701,5,85,0,0,701,702,3,
  	90,45,0,702,703,5,86,0,0,703,57,1,0,0,0,704,711,3,38,19,0,705,706,5,85,
  	0,0,706,707,3,246,123,0,707,708,5,86,0,0,708,709,3,58,29,0,709,711,1,
  	0,0,0,710,704,1,0,0,0,710,705,1,0,0,0,711,59,1,0,0,0,712,717,3,58,29,
  	0,713,714,7,5,0,0,714,716,3,58,29,0,715,713,1,0,0,0,716,719,1,0,0,0,717,
  	715,1,0,0,0,717,718,1,0,0,0,718,61,1,0,0,0,719,717,1,0,0,0,720,725,3,
  	60,30,0,721,722,7,6,0,0,722,724,3,60,30,0,723,721,1,0,0,0,724,727,1,0,
  	0,0,725,723,1,0,0,0,725,726,1,0,0,0,726,63,1,0,0,0,727,725,1,0,0,0,728,
  	733,3,62,31,0,729,730,7,7,0,0,730,732,3,62,31,0,731,729,1,0,0,0,732,735,
  	1,0,0,0,733,731,1,0,0,0,733,734,1,0,0,0,734,65,1,0,0,0,735,733,1,0,0,
  	0,736,742,3,64,32,0,737,738,3,68,34,0,738,739,3,64,32,0,739,741,1,0,0,
  	0,740,737,1,0,0,0,741,744,1,0,0,0,742,740,1,0,0,0,742,743,1,0,0,0,743,
  	67,1,0,0,0,744,742,1,0,0,0,745,746,5,103,0,0,746,750,5,103,0,0,747,748,
  	5,102,0,0,748,750,5,102,0,0,749,745,1,0,0,0,749,747,1,0,0,0,750,69,1,
  	0,0,0,751,756,3,66,33,0,752,753,7,8,0,0,753,755,3,66,33,0,754,752,1,0,
  	0,0,755,758,1,0,0,0,756,754,1,0,0,0,756,757,1,0,0,0,757,71,1,0,0,0,758,
  	756,1,0,0,0,759,764,3,70,35,0,760,761,7,9,0,0,761,763,3,70,35,0,762,760,
  	1,0,0,0,763,766,1,0,0,0,764,762,1,0,0,0,764,765,1,0,0,0,765,73,1,0,0,
  	0,766,764,1,0,0,0,767,772,3,72,36,0,768,769,5,97,0,0,769,771,3,72,36,
  	0,770,768,1,0,0,0,771,774,1,0,0,0,772,770,1,0,0,0,772,773,1,0,0,0,773,
  	75,1,0,0,0,774,772,1,0,0,0,775,780,3,74,37,0,776,777,5,96,0,0,777,779,
  	3,74,37,0,778,776,1,0,0,0,779,782,1,0,0,0,780,778,1,0,0,0,780,781,1,0,
  	0,0,781,77,1,0,0,0,782,780,1,0,0,0,783,788,3,76,38,0,784,785,5,98,0,0,
  	785,787,3,76,38,0,786,784,1,0,0,0,787,790,1,0,0,0,788,786,1,0,0,0,788,
  	789,1,0,0,0,789,79,1,0,0,0,790,788,1,0,0,0,791,796,3,78,39,0,792,793,
  	5,118,0,0,793,795,3,78,39,0,794,792,1,0,0,0,795,798,1,0,0,0,796,794,1,
  	0,0,0,796,797,1,0,0,0,797,81,1,0,0,0,798,796,1,0,0,0,799,804,3,80,40,
  	0,800,801,5,119,0,0,801,803,3,80,40,0,802,800,1,0,0,0,803,806,1,0,0,0,
  	804,802,1,0,0,0,804,805,1,0,0,0,805,83,1,0,0,0,806,804,1,0,0,0,807,813,
  	3,82,41,0,808,809,5,125,0,0,809,810,3,90,45,0,810,811,5,126,0,0,811,812,
  	3,86,43,0,812,814,1,0,0,0,813,808,1,0,0,0,813,814,1,0,0,0,814,85,1,0,
  	0,0,815,822,3,84,42,0,816,817,3,82,41,0,817,818,3,88,44,0,818,819,3,272,
  	136,0,819,822,1,0,0,0,820,822,3,368,184,0,821,815,1,0,0,0,821,816,1,0,
  	0,0,821,820,1,0,0,0,822,87,1,0,0,0,823,824,7,10,0,0,824,89,1,0,0,0,825,
  	830,3,86,43,0,826,827,5,122,0,0,827,829,3,86,43,0,828,826,1,0,0,0,829,
  	832,1,0,0,0,830,828,1,0,0,0,830,831,1,0,0,0,831,91,1,0,0,0,832,830,1,
  	0,0,0,833,834,3,84,42,0,834,93,1,0,0,0,835,849,3,96,48,0,836,849,3,118,
  	59,0,837,839,3,204,102,0,838,837,1,0,0,0,838,839,1,0,0,0,839,846,1,0,
  	0,0,840,847,3,98,49,0,841,847,3,100,50,0,842,847,3,104,52,0,843,847,3,
  	108,54,0,844,847,3,116,58,0,845,847,3,358,179,0,846,840,1,0,0,0,846,841,
  	1,0,0,0,846,842,1,0,0,0,846,843,1,0,0,0,846,844,1,0,0,0,846,845,1,0,0,
  	0,847,849,1,0,0,0,848,835,1,0,0,0,848,836,1,0,0,0,848,838,1,0,0,0,849,
  	95,1,0,0,0,850,852,3,204,102,0,851,850,1,0,0,0,851,852,1,0,0,0,852,857,
  	1,0,0,0,853,858,5,132,0,0,854,855,5,16,0,0,855,858,3,92,46,0,856,858,
  	5,27,0,0,857,853,1,0,0,0,857,854,1,0,0,0,857,856,1,0,0,0,858,859,1,0,
  	0,0,859,860,5,126,0,0,860,861,3,94,47,0,861,97,1,0,0,0,862,864,3,90,45,
  	0,863,862,1,0,0,0,863,864,1,0,0,0,864,865,1,0,0,0,865,866,5,128,0,0,866,
  	99,1,0,0,0,867,869,5,89,0,0,868,870,3,102,51,0,869,868,1,0,0,0,869,870,
  	1,0,0,0,870,871,1,0,0,0,871,872,5,90,0,0,872,101,1,0,0,0,873,875,3,94,
  	47,0,874,873,1,0,0,0,875,876,1,0,0,0,876,874,1,0,0,0,876,877,1,0,0,0,
  	877,103,1,0,0,0,878,879,5,43,0,0,879,880,5,85,0,0,880,881,3,106,53,0,
  	881,882,5,86,0,0,882,885,3,94,47,0,883,884,5,32,0,0,884,886,3,94,47,0,
  	885,883,1,0,0,0,885,886,1,0,0,0,886,894,1,0,0,0,887,888,5,67,0,0,888,
  	889,5,85,0,0,889,890,3,106,53,0,890,891,5,86,0,0,891,892,3,94,47,0,892,
  	894,1,0,0,0,893,878,1,0,0,0,893,887,1,0,0,0,894,105,1,0,0,0,895,907,3,
  	90,45,0,896,898,3,204,102,0,897,896,1,0,0,0,897,898,1,0,0,0,898,899,1,
  	0,0,0,899,900,3,138,69,0,900,904,3,226,113,0,901,902,5,101,0,0,902,905,
  	3,272,136,0,903,905,3,276,138,0,904,901,1,0,0,0,904,903,1,0,0,0,905,907,
  	1,0,0,0,906,895,1,0,0,0,906,897,1,0,0,0,907,107,1,0,0,0,908,909,5,84,
  	0,0,909,910,5,85,0,0,910,911,3,106,53,0,911,912,5,86,0,0,912,913,3,94,
  	47,0,913,942,1,0,0,0,914,915,5,29,0,0,915,916,3,94,47,0,916,917,5,84,
  	0,0,917,918,5,85,0,0,918,919,3,90,45,0,919,920,5,86,0,0,920,921,5,128,
  	0,0,921,942,1,0,0,0,922,923,5,40,0,0,923,936,5,85,0,0,924,926,3,110,55,
  	0,925,927,3,106,53,0,926,925,1,0,0,0,926,927,1,0,0,0,927,928,1,0,0,0,
  	928,930,5,128,0,0,929,931,3,90,45,0,930,929,1,0,0,0,930,931,1,0,0,0,931,
  	937,1,0,0,0,932,933,3,112,56,0,933,934,5,126,0,0,934,935,3,114,57,0,935,
  	937,1,0,0,0,936,924,1,0,0,0,936,932,1,0,0,0,937,938,1,0,0,0,938,939,5,
  	86,0,0,939,940,3,94,47,0,940,942,1,0,0,0,941,908,1,0,0,0,941,914,1,0,
  	0,0,941,922,1,0,0,0,942,109,1,0,0,0,943,946,3,98,49,0,944,946,3,128,64,
  	0,945,943,1,0,0,0,945,944,1,0,0,0,946,111,1,0,0,0,947,949,3,204,102,0,
  	948,947,1,0,0,0,948,949,1,0,0,0,949,950,1,0,0,0,950,951,3,138,69,0,951,
  	952,3,226,113,0,952,113,1,0,0,0,953,956,3,90,45,0,954,956,3,276,138,0,
  	955,953,1,0,0,0,955,954,1,0,0,0,956,115,1,0,0,0,957,967,5,15,0,0,958,
  	967,5,25,0,0,959,962,5,59,0,0,960,963,3,90,45,0,961,963,3,276,138,0,962,
  	960,1,0,0,0,962,961,1,0,0,0,962,963,1,0,0,0,963,967,1,0,0,0,964,965,5,
  	42,0,0,965,967,5,132,0,0,966,957,1,0,0,0,966,958,1,0,0,0,966,959,1,0,
  	0,0,966,964,1,0,0,0,967,968,1,0,0,0,968,969,5,128,0,0,969,117,1,0,0,0,
  	970,971,3,124,62,0,971,119,1,0,0,0,972,974,3,122,61,0,973,972,1,0,0,0,
  	974,975,1,0,0,0,975,973,1,0,0,0,975,976,1,0,0,0,976,121,1,0,0,0,977,987,
  	3,124,62,0,978,987,3,264,132,0,979,987,3,334,167,0,980,987,3,354,177,
  	0,981,987,3,356,178,0,982,987,3,202,101,0,983,987,3,188,94,0,984,987,
  	3,132,66,0,985,987,3,134,67,0,986,977,1,0,0,0,986,978,1,0,0,0,986,979,
  	1,0,0,0,986,980,1,0,0,0,986,981,1,0,0,0,986,982,1,0,0,0,986,983,1,0,0,
  	0,986,984,1,0,0,0,986,985,1,0,0,0,987,123,1,0,0,0,988,997,3,128,64,0,
  	989,997,3,200,100,0,990,997,3,192,96,0,991,997,3,196,98,0,992,997,3,198,
  	99,0,993,997,3,130,65,0,994,997,3,126,63,0,995,997,3,172,86,0,996,988,
  	1,0,0,0,996,989,1,0,0,0,996,990,1,0,0,0,996,991,1,0,0,0,996,992,1,0,0,
  	0,996,993,1,0,0,0,996,994,1,0,0,0,996,995,1,0,0,0,997,125,1,0,0,0,998,
  	999,5,79,0,0,999,1001,5,132,0,0,1000,1002,3,204,102,0,1001,1000,1,0,0,
  	0,1001,1002,1,0,0,0,1002,1003,1,0,0,0,1003,1004,5,101,0,0,1004,1005,3,
  	246,123,0,1005,1006,5,128,0,0,1006,127,1,0,0,0,1007,1009,3,138,69,0,1008,
  	1007,1,0,0,0,1008,1009,1,0,0,0,1009,1011,1,0,0,0,1010,1012,3,222,111,
  	0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012,1013,1,0,0,0,1013,1022,5,128,
  	0,0,1014,1016,3,204,102,0,1015,1017,3,138,69,0,1016,1015,1,0,0,0,1016,
  	1017,1,0,0,0,1017,1018,1,0,0,0,1018,1019,3,222,111,0,1019,1020,5,128,
  	0,0,1020,1022,1,0,0,0,1021,1008,1,0,0,0,1021,1014,1,0,0,0,1022,129,1,
  	0,0,0,1023,1024,5,64,0,0,1024,1025,5,85,0,0,1025,1026,3,92,46,0,1026,
  	1027,5,122,0,0,1027,1028,5,4,0,0,1028,1029,5,86,0,0,1029,1030,5,128,0,
  	0,1030,131,1,0,0,0,1031,1032,5,128,0,0,1032,133,1,0,0,0,1033,1034,3,204,
  	102,0,1034,1035,5,128,0,0,1035,135,1,0,0,0,1036,1043,3,140,70,0,1037,
  	1043,3,146,73,0,1038,1043,3,142,71,0,1039,1043,5,41,0,0,1040,1043,5,74,
  	0,0,1041,1043,5,23,0,0,1042,1036,1,0,0,0,1042,1037,1,0,0,0,1042,1038,
  	1,0,0,0,1042,1039,1,0,0,0,1042,1040,1,0,0,0,1042,1041,1,0,0,0,1043,137,
  	1,0,0,0,1044,1046,3,136,68,0,1045,1044,1,0,0,0,1046,1047,1,0,0,0,1047,
  	1048,1,0,0,0,1047,1045,1,0,0,0,1048,1050,1,0,0,0,1049,1051,3,204,102,
  	0,1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,139,1,0,0,0,1052,1053,7,11,
  	0,0,1053,141,1,0,0,0,1054,1055,7,12,0,0,1055,143,1,0,0,0,1056,1057,5,
  	132,0,0,1057,145,1,0,0,0,1058,1062,3,148,74,0,1059,1062,3,280,140,0,1060,
  	1062,3,168,84,0,1061,1058,1,0,0,0,1061,1059,1,0,0,0,1061,1060,1,0,0,0,
  	1062,147,1,0,0,0,1063,1068,3,158,79,0,1064,1068,3,164,82,0,1065,1068,
  	3,352,176,0,1066,1068,3,240,120,0,1067,1063,1,0,0,0,1067,1064,1,0,0,0,
  	1067,1065,1,0,0,0,1067,1066,1,0,0,0,1068,149,1,0,0,0,1069,1071,3,146,
  	73,0,1070,1069,1,0,0,0,1071,1072,1,0,0,0,1072,1070,1,0,0,0,1072,1073,
  	1,0,0,0,1073,1075,1,0,0,0,1074,1076,3,204,102,0,1075,1074,1,0,0,0,1075,
  	1076,1,0,0,0,1076,151,1,0,0,0,1077,1079,3,148,74,0,1078,1077,1,0,0,0,
  	1079,1080,1,0,0,0,1080,1078,1,0,0,0,1080,1081,1,0,0,0,1081,1083,1,0,0,
  	0,1082,1084,3,204,102,0,1083,1082,1,0,0,0,1083,1084,1,0,0,0,1084,153,
  	1,0,0,0,1085,1086,7,13,0,0,1086,155,1,0,0,0,1087,1088,7,14,0,0,1088,157,
  	1,0,0,0,1089,1091,3,10,5,0,1090,1089,1,0,0,0,1090,1091,1,0,0,0,1091,1092,
  	1,0,0,0,1092,1142,3,160,80,0,1093,1094,3,10,5,0,1094,1095,5,68,0,0,1095,
  	1096,3,342,171,0,1096,1142,1,0,0,0,1097,1142,3,156,78,0,1098,1100,3,156,
  	78,0,1099,1098,1,0,0,0,1099,1100,1,0,0,0,1100,1102,1,0,0,0,1101,1103,
  	3,154,77,0,1102,1101,1,0,0,0,1103,1104,1,0,0,0,1104,1102,1,0,0,0,1104,
  	1105,1,0,0,0,1105,1142,1,0,0,0,1106,1108,3,156,78,0,1107,1106,1,0,0,0,
  	1107,1108,1,0,0,0,1108,1109,1,0,0,0,1109,1142,5,18,0,0,1110,1112,3,156,
  	78,0,1111,1110,1,0,0,0,1111,1112,1,0,0,0,1112,1113,1,0,0,0,1113,1142,
  	5,19,0,0,1114,1116,3,156,78,0,1115,1114,1,0,0,0,1115,1116,1,0,0,0,1116,
  	1117,1,0,0,0,1117,1142,5,20,0,0,1118,1120,3,156,78,0,1119,1118,1,0,0,
  	0,1119,1120,1,0,0,0,1120,1121,1,0,0,0,1121,1142,5,83,0,0,1122,1142,5,
  	14,0,0,1123,1125,3,156,78,0,1124,1123,1,0,0,0,1124,1125,1,0,0,0,1125,
  	1129,1,0,0,0,1126,1128,3,154,77,0,1127,1126,1,0,0,0,1128,1131,1,0,0,0,
  	1129,1127,1,0,0,0,1129,1130,1,0,0,0,1130,1132,1,0,0,0,1131,1129,1,0,0,
  	0,1132,1142,5,45,0,0,1133,1142,5,39,0,0,1134,1136,3,154,77,0,1135,1134,
  	1,0,0,0,1135,1136,1,0,0,0,1136,1137,1,0,0,0,1137,1142,5,30,0,0,1138,1142,
  	5,81,0,0,1139,1142,5,13,0,0,1140,1142,3,162,81,0,1141,1090,1,0,0,0,1141,
  	1093,1,0,0,0,1141,1097,1,0,0,0,1141,1099,1,0,0,0,1141,1107,1,0,0,0,1141,
  	1111,1,0,0,0,1141,1115,1,0,0,0,1141,1119,1,0,0,0,1141,1122,1,0,0,0,1141,
  	1124,1,0,0,0,1141,1133,1,0,0,0,1141,1135,1,0,0,0,1141,1138,1,0,0,0,1141,
  	1139,1,0,0,0,1141,1140,1,0,0,0,1142,159,1,0,0,0,1143,1148,3,278,139,0,
  	1144,1148,3,166,83,0,1145,1148,3,144,72,0,1146,1148,3,342,171,0,1147,
  	1143,1,0,0,0,1147,1144,1,0,0,0,1147,1145,1,0,0,0,1147,1146,1,0,0,0,1148,
  	161,1,0,0,0,1149,1150,5,26,0,0,1150,1153,5,85,0,0,1151,1154,3,90,45,0,
  	1152,1154,5,13,0,0,1153,1151,1,0,0,0,1153,1152,1,0,0,0,1154,1155,1,0,
  	0,0,1155,1156,5,86,0,0,1156,163,1,0,0,0,1157,1172,3,288,144,0,1158,1160,
  	3,204,102,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,1160,1162,1,0,0,0,1161,
  	1163,3,10,5,0,1162,1161,1,0,0,0,1162,1163,1,0,0,0,1163,1164,1,0,0,0,1164,
  	1173,5,132,0,0,1165,1173,3,342,171,0,1166,1168,3,10,5,0,1167,1169,5,68,
  	0,0,1168,1167,1,0,0,0,1168,1169,1,0,0,0,1169,1170,1,0,0,0,1170,1171,3,
  	342,171,0,1171,1173,1,0,0,0,1172,1159,1,0,0,0,1172,1165,1,0,0,0,1172,
  	1166,1,0,0,0,1173,1180,1,0,0,0,1174,1176,5,33,0,0,1175,1177,3,10,5,0,
  	1176,1175,1,0,0,0,1176,1177,1,0,0,0,1177,1178,1,0,0,0,1178,1180,5,132,
  	0,0,1179,1157,1,0,0,0,1179,1174,1,0,0,0,1180,165,1,0,0,0,1181,1182,5,
  	132,0,0,1182,167,1,0,0,0,1183,1184,3,170,85,0,1184,1189,5,89,0,0,1185,
  	1187,3,178,89,0,1186,1188,5,122,0,0,1187,1186,1,0,0,0,1187,1188,1,0,0,
  	0,1188,1190,1,0,0,0,1189,1185,1,0,0,0,1189,1190,1,0,0,0,1190,1191,1,0,
  	0,0,1191,1192,5,90,0,0,1192,169,1,0,0,0,1193,1195,3,174,87,0,1194,1196,
  	3,204,102,0,1195,1194,1,0,0,0,1195,1196,1,0,0,0,1196,1201,1,0,0,0,1197,
  	1199,3,10,5,0,1198,1197,1,0,0,0,1198,1199,1,0,0,0,1199,1200,1,0,0,0,1200,
  	1202,5,132,0,0,1201,1198,1,0,0,0,1201,1202,1,0,0,0,1202,1204,1,0,0,0,
  	1203,1205,3,176,88,0,1204,1203,1,0,0,0,1204,1205,1,0,0,0,1205,171,1,0,
  	0,0,1206,1208,3,174,87,0,1207,1209,3,204,102,0,1208,1207,1,0,0,0,1208,
  	1209,1,0,0,0,1209,1210,1,0,0,0,1210,1212,5,132,0,0,1211,1213,3,176,88,
  	0,1212,1211,1,0,0,0,1212,1213,1,0,0,0,1213,1214,1,0,0,0,1214,1215,5,128,
  	0,0,1215,173,1,0,0,0,1216,1218,5,33,0,0,1217,1219,7,15,0,0,1218,1217,
  	1,0,0,0,1218,1219,1,0,0,0,1219,175,1,0,0,0,1220,1221,5,126,0,0,1221,1222,
  	3,150,75,0,1222,177,1,0,0,0,1223,1228,3,180,90,0,1224,1225,5,122,0,0,
  	1225,1227,3,180,90,0,1226,1224,1,0,0,0,1227,1230,1,0,0,0,1228,1226,1,
  	0,0,0,1228,1229,1,0,0,0,1229,179,1,0,0,0,1230,1228,1,0,0,0,1231,1234,
  	3,182,91,0,1232,1233,5,101,0,0,1233,1235,3,92,46,0,1234,1232,1,0,0,0,
  	1234,1235,1,0,0,0,1235,181,1,0,0,0,1236,1237,5,132,0,0,1237,183,1,0,0,
  	0,1238,1241,3,186,93,0,1239,1241,3,190,95,0,1240,1238,1,0,0,0,1240,1239,
  	1,0,0,0,1241,185,1,0,0,0,1242,1243,5,132,0,0,1243,187,1,0,0,0,1244,1246,
  	5,44,0,0,1245,1244,1,0,0,0,1245,1246,1,0,0,0,1246,1247,1,0,0,0,1247,1250,
  	5,48,0,0,1248,1251,5,132,0,0,1249,1251,3,186,93,0,1250,1248,1,0,0,0,1250,
  	1249,1,0,0,0,1250,1251,1,0,0,0,1251,1252,1,0,0,0,1252,1254,5,89,0,0,1253,
  	1255,3,120,60,0,1254,1253,1,0,0,0,1254,1255,1,0,0,0,1255,1256,1,0,0,0,
  	1256,1257,5,90,0,0,1257,189,1,0,0,0,1258,1259,5,132,0,0,1259,191,1,0,
  	0,0,1260,1261,5,48,0,0,1261,1262,5,132,0,0,1262,1263,5,101,0,0,1263,1264,
  	3,194,97,0,1264,1265,5,128,0,0,1265,193,1,0,0,0,1266,1268,3,10,5,0,1267,
  	1266,1,0,0,0,1267,1268,1,0,0,0,1268,1269,1,0,0,0,1269,1270,3,184,92,0,
  	1270,195,1,0,0,0,1271,1277,5,79,0,0,1272,1274,5,76,0,0,1273,1272,1,0,
  	0,0,1273,1274,1,0,0,0,1274,1275,1,0,0,0,1275,1278,3,10,5,0,1276,1278,
  	5,127,0,0,1277,1273,1,0,0,0,1277,1276,1,0,0,0,1278,1279,1,0,0,0,1279,
  	1280,3,6,3,0,1280,1281,5,128,0,0,1281,197,1,0,0,0,1282,1284,3,204,102,
  	0,1283,1282,1,0,0,0,1283,1284,1,0,0,0,1284,1285,1,0,0,0,1285,1286,5,79,
  	0,0,1286,1288,5,48,0,0,1287,1289,3,10,5,0,1288,1287,1,0,0,0,1288,1289,
  	1,0,0,0,1289,1290,1,0,0,0,1290,1291,3,184,92,0,1291,1292,5,128,0,0,1292,
  	199,1,0,0,0,1293,1294,5,12,0,0,1294,1295,5,85,0,0,1295,1296,5,4,0,0,1296,
  	1297,5,86,0,0,1297,1298,5,128,0,0,1298,201,1,0,0,0,1299,1300,5,36,0,0,
  	1300,1307,5,4,0,0,1301,1303,5,89,0,0,1302,1304,3,120,60,0,1303,1302,1,
  	0,0,0,1303,1304,1,0,0,0,1304,1305,1,0,0,0,1305,1308,5,90,0,0,1306,1308,
  	3,122,61,0,1307,1301,1,0,0,0,1307,1306,1,0,0,0,1308,203,1,0,0,0,1309,
  	1311,3,206,103,0,1310,1309,1,0,0,0,1311,1312,1,0,0,0,1312,1310,1,0,0,
  	0,1312,1313,1,0,0,0,1313,205,1,0,0,0,1314,1315,5,87,0,0,1315,1317,5,87,
  	0,0,1316,1318,3,210,105,0,1317,1316,1,0,0,0,1317,1318,1,0,0,0,1318,1319,
  	1,0,0,0,1319,1320,5,88,0,0,1320,1323,5,88,0,0,1321,1323,3,208,104,0,1322,
  	1314,1,0,0,0,1322,1321,1,0,0,0,1323,207,1,0,0,0,1324,1325,5,10,0,0,1325,
  	1328,5,85,0,0,1326,1329,3,246,123,0,1327,1329,3,92,46,0,1328,1326,1,0,
  	0,0,1328,1327,1,0,0,0,1329,1331,1,0,0,0,1330,1332,5,131,0,0,1331,1330,
  	1,0,0,0,1331,1332,1,0,0,0,1332,1333,1,0,0,0,1333,1334,5,86,0,0,1334,209,
  	1,0,0,0,1335,1340,3,212,106,0,1336,1337,5,122,0,0,1337,1339,3,212,106,
  	0,1338,1336,1,0,0,0,1339,1342,1,0,0,0,1340,1338,1,0,0,0,1340,1341,1,0,
  	0,0,1341,1344,1,0,0,0,1342,1340,1,0,0,0,1343,1345,5,131,0,0,1344,1343,
  	1,0,0,0,1344,1345,1,0,0,0,1345,211,1,0,0,0,1346,1347,3,214,107,0,1347,
  	1348,5,127,0,0,1348,1350,1,0,0,0,1349,1346,1,0,0,0,1349,1350,1,0,0,0,
  	1350,1351,1,0,0,0,1351,1353,5,132,0,0,1352,1354,3,216,108,0,1353,1352,
  	1,0,0,0,1353,1354,1,0,0,0,1354,213,1,0,0,0,1355,1356,5,132,0,0,1356,215,
  	1,0,0,0,1357,1359,5,85,0,0,1358,1360,3,218,109,0,1359,1358,1,0,0,0,1359,
  	1360,1,0,0,0,1360,1361,1,0,0,0,1361,1362,5,86,0,0,1362,217,1,0,0,0,1363,
  	1365,3,220,110,0,1364,1363,1,0,0,0,1365,1366,1,0,0,0,1366,1364,1,0,0,
  	0,1366,1367,1,0,0,0,1367,219,1,0,0,0,1368,1369,5,85,0,0,1369,1370,3,218,
  	109,0,1370,1371,5,86,0,0,1371,1386,1,0,0,0,1372,1373,5,87,0,0,1373,1374,
  	3,218,109,0,1374,1375,5,88,0,0,1375,1386,1,0,0,0,1376,1377,5,89,0,0,1377,
  	1378,3,218,109,0,1378,1379,5,90,0,0,1379,1386,1,0,0,0,1380,1382,8,16,
  	0,0,1381,1380,1,0,0,0,1382,1383,1,0,0,0,1383,1381,1,0,0,0,1383,1384,1,
  	0,0,0,1384,1386,1,0,0,0,1385,1368,1,0,0,0,1385,1372,1,0,0,0,1385,1376,
  	1,0,0,0,1385,1381,1,0,0,0,1386,221,1,0,0,0,1387,1392,3,224,112,0,1388,
  	1389,5,122,0,0,1389,1391,3,224,112,0,1390,1388,1,0,0,0,1391,1394,1,0,
  	0,0,1392,1390,1,0,0,0,1392,1393,1,0,0,0,1393,223,1,0,0,0,1394,1392,1,
  	0,0,0,1395,1397,3,226,113,0,1396,1398,3,268,134,0,1397,1396,1,0,0,0,1397,
  	1398,1,0,0,0,1398,225,1,0,0,0,1399,1405,3,228,114,0,1400,1401,3,230,115,
  	0,1401,1402,3,232,116,0,1402,1403,3,234,117,0,1403,1405,1,0,0,0,1404,
  	1399,1,0,0,0,1404,1400,1,0,0,0,1405,227,1,0,0,0,1406,1408,3,236,118,0,
  	1407,1409,5,22,0,0,1408,1407,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0,
  	0,0,1410,1406,1,0,0,0,1411,1414,1,0,0,0,1412,1410,1,0,0,0,1412,1413,1,
  	0,0,0,1413,1415,1,0,0,0,1414,1412,1,0,0,0,1415,1416,3,230,115,0,1416,
  	229,1,0,0,0,1417,1418,6,115,-1,0,1418,1420,3,244,122,0,1419,1421,3,204,
  	102,0,1420,1419,1,0,0,0,1420,1421,1,0,0,0,1421,1427,1,0,0,0,1422,1423,
  	5,85,0,0,1423,1424,3,228,114,0,1424,1425,5,86,0,0,1425,1427,1,0,0,0,1426,
  	1417,1,0,0,0,1426,1422,1,0,0,0,1427,1442,1,0,0,0,1428,1438,10,2,0,0,1429,
  	1439,3,232,116,0,1430,1432,5,87,0,0,1431,1433,3,92,46,0,1432,1431,1,0,
  	0,0,1432,1433,1,0,0,0,1433,1434,1,0,0,0,1434,1436,5,88,0,0,1435,1437,
  	3,204,102,0,1436,1435,1,0,0,0,1436,1437,1,0,0,0,1437,1439,1,0,0,0,1438,
  	1429,1,0,0,0,1438,1430,1,0,0,0,1439,1441,1,0,0,0,1440,1428,1,0,0,0,1441,
  	1444,1,0,0,0,1442,1440,1,0,0,0,1442,1443,1,0,0,0,1443,231,1,0,0,0,1444,
  	1442,1,0,0,0,1445,1447,5,85,0,0,1446,1448,3,258,129,0,1447,1446,1,0,0,
  	0,1447,1448,1,0,0,0,1448,1449,1,0,0,0,1449,1451,5,86,0,0,1450,1452,3,
  	238,119,0,1451,1450,1,0,0,0,1451,1452,1,0,0,0,1452,1454,1,0,0,0,1453,
  	1455,3,242,121,0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,1457,1,0,0,
  	0,1456,1458,3,370,185,0,1457,1456,1,0,0,0,1457,1458,1,0,0,0,1458,1460,
  	1,0,0,0,1459,1461,3,204,102,0,1460,1459,1,0,0,0,1460,1461,1,0,0,0,1461,
  	233,1,0,0,0,1462,1463,5,124,0,0,1463,1465,3,152,76,0,1464,1466,3,248,
  	124,0,1465,1464,1,0,0,0,1465,1466,1,0,0,0,1466,235,1,0,0,0,1467,1469,
  	7,17,0,0,1468,1470,3,204,102,0,1469,1468,1,0,0,0,1469,1470,1,0,0,0,1470,
  	1482,1,0,0,0,1471,1473,3,10,5,0,1472,1471,1,0,0,0,1472,1473,1,0,0,0,1473,
  	1474,1,0,0,0,1474,1476,5,93,0,0,1475,1477,3,204,102,0,1476,1475,1,0,0,
  	0,1476,1477,1,0,0,0,1477,1479,1,0,0,0,1478,1480,3,238,119,0,1479,1478,
  	1,0,0,0,1479,1480,1,0,0,0,1480,1482,1,0,0,0,1481,1467,1,0,0,0,1481,1472,
  	1,0,0,0,1482,237,1,0,0,0,1483,1485,3,240,120,0,1484,1483,1,0,0,0,1485,
  	1486,1,0,0,0,1486,1484,1,0,0,0,1486,1487,1,0,0,0,1487,239,1,0,0,0,1488,
  	1489,7,18,0,0,1489,241,1,0,0,0,1490,1491,7,17,0,0,1491,243,1,0,0,0,1492,
  	1494,5,131,0,0,1493,1492,1,0,0,0,1493,1494,1,0,0,0,1494,1495,1,0,0,0,
  	1495,1496,3,4,2,0,1496,245,1,0,0,0,1497,1499,3,150,75,0,1498,1500,3,248,
  	124,0,1499,1498,1,0,0,0,1499,1500,1,0,0,0,1500,247,1,0,0,0,1501,1510,
  	3,250,125,0,1502,1504,3,252,126,0,1503,1502,1,0,0,0,1503,1504,1,0,0,0,
  	1504,1505,1,0,0,0,1505,1506,3,232,116,0,1506,1507,3,234,117,0,1507,1510,
  	1,0,0,0,1508,1510,3,254,127,0,1509,1501,1,0,0,0,1509,1503,1,0,0,0,1509,
  	1508,1,0,0,0,1510,249,1,0,0,0,1511,1521,3,252,126,0,1512,1514,3,236,118,
  	0,1513,1512,1,0,0,0,1514,1515,1,0,0,0,1515,1513,1,0,0,0,1515,1516,1,0,
  	0,0,1516,1518,1,0,0,0,1517,1519,3,252,126,0,1518,1517,1,0,0,0,1518,1519,
  	1,0,0,0,1519,1521,1,0,0,0,1520,1511,1,0,0,0,1520,1513,1,0,0,0,1521,251,
  	1,0,0,0,1522,1523,6,126,-1,0,1523,1537,3,232,116,0,1524,1526,5,87,0,0,
  	1525,1527,3,92,46,0,1526,1525,1,0,0,0,1526,1527,1,0,0,0,1527,1528,1,0,
  	0,0,1528,1530,5,88,0,0,1529,1531,3,204,102,0,1530,1529,1,0,0,0,1530,1531,
  	1,0,0,0,1531,1537,1,0,0,0,1532,1533,5,85,0,0,1533,1534,3,250,125,0,1534,
  	1535,5,86,0,0,1535,1537,1,0,0,0,1536,1522,1,0,0,0,1536,1524,1,0,0,0,1536,
  	1532,1,0,0,0,1537,1553,1,0,0,0,1538,1549,10,4,0,0,1539,1550,3,232,116,
  	0,1540,1541,3,252,126,0,1541,1543,5,87,0,0,1542,1544,3,92,46,0,1543,1542,
  	1,0,0,0,1543,1544,1,0,0,0,1544,1545,1,0,0,0,1545,1547,5,88,0,0,1546,1548,
  	3,204,102,0,1547,1546,1,0,0,0,1547,1548,1,0,0,0,1548,1550,1,0,0,0,1549,
  	1539,1,0,0,0,1549,1540,1,0,0,0,1550,1552,1,0,0,0,1551,1538,1,0,0,0,1552,
  	1555,1,0,0,0,1553,1551,1,0,0,0,1553,1554,1,0,0,0,1554,253,1,0,0,0,1555,
  	1553,1,0,0,0,1556,1558,3,236,118,0,1557,1556,1,0,0,0,1558,1561,1,0,0,
  	0,1559,1557,1,0,0,0,1559,1560,1,0,0,0,1560,1562,1,0,0,0,1561,1559,1,0,
  	0,0,1562,1563,3,256,128,0,1563,255,1,0,0,0,1564,1565,6,128,-1,0,1565,
  	1566,5,131,0,0,1566,1581,1,0,0,0,1567,1577,10,2,0,0,1568,1578,3,232,116,
  	0,1569,1571,5,87,0,0,1570,1572,3,92,46,0,1571,1570,1,0,0,0,1571,1572,
  	1,0,0,0,1572,1573,1,0,0,0,1573,1575,5,88,0,0,1574,1576,3,204,102,0,1575,
  	1574,1,0,0,0,1575,1576,1,0,0,0,1576,1578,1,0,0,0,1577,1568,1,0,0,0,1577,
  	1569,1,0,0,0,1578,1580,1,0,0,0,1579,1567,1,0,0,0,1580,1583,1,0,0,0,1581,
  	1579,1,0,0,0,1581,1582,1,0,0,0,1582,257,1,0,0,0,1583,1581,1,0,0,0,1584,
  	1589,3,260,130,0,1585,1587,5,122,0,0,1586,1585,1,0,0,0,1586,1587,1,0,
  	0,0,1587,1588,1,0,0,0,1588,1590,5,131,0,0,1589,1586,1,0,0,0,1589,1590,
  	1,0,0,0,1590,259,1,0,0,0,1591,1596,3,262,131,0,1592,1593,5,122,0,0,1593,
  	1595,3,262,131,0,1594,1592,1,0,0,0,1595,1598,1,0,0,0,1596,1594,1,0,0,
  	0,1596,1597,1,0,0,0,1597,261,1,0,0,0,1598,1596,1,0,0,0,1599,1601,3,204,
  	102,0,1600,1599,1,0,0,0,1600,1601,1,0,0,0,1601,1602,1,0,0,0,1602,1607,
  	3,138,69,0,1603,1608,3,226,113,0,1604,1606,3,248,124,0,1605,1604,1,0,
  	0,0,1605,1606,1,0,0,0,1606,1608,1,0,0,0,1607,1603,1,0,0,0,1607,1605,1,
  	0,0,0,1608,1611,1,0,0,0,1609,1610,5,101,0,0,1610,1612,3,272,136,0,1611,
  	1609,1,0,0,0,1611,1612,1,0,0,0,1612,263,1,0,0,0,1613,1615,3,204,102,0,
  	1614,1613,1,0,0,0,1614,1615,1,0,0,0,1615,1617,1,0,0,0,1616,1618,3,138,
  	69,0,1617,1616,1,0,0,0,1617,1618,1,0,0,0,1618,1619,1,0,0,0,1619,1621,
  	3,226,113,0,1620,1622,3,298,149,0,1621,1620,1,0,0,0,1621,1622,1,0,0,0,
  	1622,1623,1,0,0,0,1623,1624,3,266,133,0,1624,265,1,0,0,0,1625,1627,3,
  	322,161,0,1626,1625,1,0,0,0,1626,1627,1,0,0,0,1627,1628,1,0,0,0,1628,
  	1634,3,100,50,0,1629,1634,3,360,180,0,1630,1631,5,101,0,0,1631,1632,7,
  	19,0,0,1632,1634,5,128,0,0,1633,1626,1,0,0,0,1633,1629,1,0,0,0,1633,1630,
  	1,0,0,0,1634,267,1,0,0,0,1635,1641,3,270,135,0,1636,1637,5,85,0,0,1637,
  	1638,3,34,17,0,1638,1639,5,86,0,0,1639,1641,1,0,0,0,1640,1635,1,0,0,0,
  	1640,1636,1,0,0,0,1641,269,1,0,0,0,1642,1643,5,101,0,0,1643,1646,3,272,
  	136,0,1644,1646,3,276,138,0,1645,1642,1,0,0,0,1645,1644,1,0,0,0,1646,
  	271,1,0,0,0,1647,1650,3,86,43,0,1648,1650,3,276,138,0,1649,1647,1,0,0,
  	0,1649,1648,1,0,0,0,1650,273,1,0,0,0,1651,1653,3,272,136,0,1652,1654,
  	5,131,0,0,1653,1652,1,0,0,0,1653,1654,1,0,0,0,1654,1662,1,0,0,0,1655,
  	1656,5,122,0,0,1656,1658,3,272,136,0,1657,1659,5,131,0,0,1658,1657,1,
  	0,0,0,1658,1659,1,0,0,0,1659,1661,1,0,0,0,1660,1655,1,0,0,0,1661,1664,
  	1,0,0,0,1662,1660,1,0,0,0,1662,1663,1,0,0,0,1663,275,1,0,0,0,1664,1662,
  	1,0,0,0,1665,1670,5,89,0,0,1666,1668,3,274,137,0,1667,1669,5,122,0,0,
  	1668,1667,1,0,0,0,1668,1669,1,0,0,0,1669,1671,1,0,0,0,1670,1666,1,0,0,
  	0,1670,1671,1,0,0,0,1671,1672,1,0,0,0,1672,1673,5,90,0,0,1673,277,1,0,
  	0,0,1674,1677,5,132,0,0,1675,1677,3,342,171,0,1676,1674,1,0,0,0,1676,
  	1675,1,0,0,0,1677,279,1,0,0,0,1678,1679,3,282,141,0,1679,1681,5,89,0,
  	0,1680,1682,3,290,145,0,1681,1680,1,0,0,0,1681,1682,1,0,0,0,1682,1683,
  	1,0,0,0,1683,1684,5,90,0,0,1684,281,1,0,0,0,1685,1687,3,288,144,0,1686,
  	1688,3,204,102,0,1687,1686,1,0,0,0,1687,1688,1,0,0,0,1688,1693,1,0,0,
  	0,1689,1691,3,284,142,0,1690,1692,3,286,143,0,1691,1690,1,0,0,0,1691,
  	1692,1,0,0,0,1692,1694,1,0,0,0,1693,1689,1,0,0,0,1693,1694,1,0,0,0,1694,
  	1696,1,0,0,0,1695,1697,3,304,152,0,1696,1695,1,0,0,0,1696,1697,1,0,0,
  	0,1697,1709,1,0,0,0,1698,1700,5,77,0,0,1699,1701,3,204,102,0,1700,1699,
  	1,0,0,0,1700,1701,1,0,0,0,1701,1706,1,0,0,0,1702,1704,3,284,142,0,1703,
  	1705,3,286,143,0,1704,1703,1,0,0,0,1704,1705,1,0,0,0,1705,1707,1,0,0,
  	0,1706,1702,1,0,0,0,1706,1707,1,0,0,0,1707,1709,1,0,0,0,1708,1685,1,0,
  	0,0,1708,1698,1,0,0,0,1709,283,1,0,0,0,1710,1712,3,10,5,0,1711,1710,1,
  	0,0,0,1711,1712,1,0,0,0,1712,1713,1,0,0,0,1713,1714,3,278,139,0,1714,
  	285,1,0,0,0,1715,1716,5,38,0,0,1716,287,1,0,0,0,1717,1718,7,15,0,0,1718,
  	289,1,0,0,0,1719,1724,3,292,146,0,1720,1721,3,314,157,0,1721,1722,5,126,
  	0,0,1722,1724,1,0,0,0,1723,1719,1,0,0,0,1723,1720,1,0,0,0,1724,1725,1,
  	0,0,0,1725,1723,1,0,0,0,1725,1726,1,0,0,0,1726,291,1,0,0,0,1727,1729,
  	3,204,102,0,1728,1727,1,0,0,0,1728,1729,1,0,0,0,1729,1731,1,0,0,0,1730,
  	1732,3,138,69,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,1734,1,0,0,0,
  	1733,1735,3,294,147,0,1734,1733,1,0,0,0,1734,1735,1,0,0,0,1735,1736,1,
  	0,0,0,1736,1744,5,128,0,0,1737,1744,3,264,132,0,1738,1744,3,196,98,0,
  	1739,1744,3,130,65,0,1740,1744,3,334,167,0,1741,1744,3,126,63,0,1742,
  	1744,3,132,66,0,1743,1728,1,0,0,0,1743,1737,1,0,0,0,1743,1738,1,0,0,0,
  	1743,1739,1,0,0,0,1743,1740,1,0,0,0,1743,1741,1,0,0,0,1743,1742,1,0,0,
  	0,1744,293,1,0,0,0,1745,1750,3,296,148,0,1746,1747,5,122,0,0,1747,1749,
  	3,296,148,0,1748,1746,1,0,0,0,1749,1752,1,0,0,0,1750,1748,1,0,0,0,1750,
  	1751,1,0,0,0,1751,295,1,0,0,0,1752,1750,1,0,0,0,1753,1763,3,226,113,0,
  	1754,1756,3,298,149,0,1755,1754,1,0,0,0,1755,1756,1,0,0,0,1756,1758,1,
  	0,0,0,1757,1759,3,302,151,0,1758,1757,1,0,0,0,1758,1759,1,0,0,0,1759,
  	1764,1,0,0,0,1760,1762,3,270,135,0,1761,1760,1,0,0,0,1761,1762,1,0,0,
  	0,1762,1764,1,0,0,0,1763,1755,1,0,0,0,1763,1761,1,0,0,0,1764,1774,1,0,
  	0,0,1765,1767,5,132,0,0,1766,1765,1,0,0,0,1766,1767,1,0,0,0,1767,1769,
  	1,0,0,0,1768,1770,3,204,102,0,1769,1768,1,0,0,0,1769,1770,1,0,0,0,1770,
  	1771,1,0,0,0,1771,1772,5,126,0,0,1772,1774,3,92,46,0,1773,1753,1,0,0,
  	0,1773,1766,1,0,0,0,1774,297,1,0,0,0,1775,1777,3,300,150,0,1776,1775,
  	1,0,0,0,1777,1778,1,0,0,0,1778,1776,1,0,0,0,1778,1779,1,0,0,0,1779,299,
  	1,0,0,0,1780,1781,7,20,0,0,1781,301,1,0,0,0,1782,1783,5,101,0,0,1783,
  	1784,5,134,0,0,1784,1785,6,151,-1,0,1785,303,1,0,0,0,1786,1787,5,126,
  	0,0,1787,1788,3,306,153,0,1788,305,1,0,0,0,1789,1791,3,308,154,0,1790,
  	1792,5,131,0,0,1791,1790,1,0,0,0,1791,1792,1,0,0,0,1792,1800,1,0,0,0,
  	1793,1794,5,122,0,0,1794,1796,3,308,154,0,1795,1797,5,131,0,0,1796,1795,
  	1,0,0,0,1796,1797,1,0,0,0,1797,1799,1,0,0,0,1798,1793,1,0,0,0,1799,1802,
  	1,0,0,0,1800,1798,1,0,0,0,1800,1801,1,0,0,0,1801,307,1,0,0,0,1802,1800,
  	1,0,0,0,1803,1805,3,204,102,0,1804,1803,1,0,0,0,1804,1805,1,0,0,0,1805,
  	1818,1,0,0,0,1806,1819,3,312,156,0,1807,1809,5,80,0,0,1808,1810,3,314,
  	157,0,1809,1808,1,0,0,0,1809,1810,1,0,0,0,1810,1811,1,0,0,0,1811,1819,
  	3,312,156,0,1812,1814,3,314,157,0,1813,1815,5,80,0,0,1814,1813,1,0,0,
  	0,1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,1817,3,312,156,0,1817,1819,
  	1,0,0,0,1818,1806,1,0,0,0,1818,1807,1,0,0,0,1818,1812,1,0,0,0,1819,309,
  	1,0,0,0,1820,1822,3,10,5,0,1821,1820,1,0,0,0,1821,1822,1,0,0,0,1822,1823,
  	1,0,0,0,1823,1826,3,278,139,0,1824,1826,3,162,81,0,1825,1821,1,0,0,0,
  	1825,1824,1,0,0,0,1826,311,1,0,0,0,1827,1828,3,310,155,0,1828,313,1,0,
  	0,0,1829,1830,7,21,0,0,1830,315,1,0,0,0,1831,1832,5,52,0,0,1832,1833,
  	3,318,159,0,1833,317,1,0,0,0,1834,1836,3,150,75,0,1835,1837,3,320,160,
  	0,1836,1835,1,0,0,0,1836,1837,1,0,0,0,1837,319,1,0,0,0,1838,1840,3,236,
  	118,0,1839,1841,3,320,160,0,1840,1839,1,0,0,0,1840,1841,1,0,0,0,1841,
  	321,1,0,0,0,1842,1843,5,126,0,0,1843,1844,3,324,162,0,1844,323,1,0,0,
  	0,1845,1847,3,326,163,0,1846,1848,5,131,0,0,1847,1846,1,0,0,0,1847,1848,
  	1,0,0,0,1848,1856,1,0,0,0,1849,1850,5,122,0,0,1850,1852,3,326,163,0,1851,
  	1853,5,131,0,0,1852,1851,1,0,0,0,1852,1853,1,0,0,0,1853,1855,1,0,0,0,
  	1854,1849,1,0,0,0,1855,1858,1,0,0,0,1856,1854,1,0,0,0,1856,1857,1,0,0,
  	0,1857,325,1,0,0,0,1858,1856,1,0,0,0,1859,1866,3,328,164,0,1860,1862,
  	5,85,0,0,1861,1863,3,34,17,0,1862,1861,1,0,0,0,1862,1863,1,0,0,0,1863,
  	1864,1,0,0,0,1864,1867,5,86,0,0,1865,1867,3,276,138,0,1866,1860,1,0,0,
  	0,1866,1865,1,0,0,0,1867,327,1,0,0,0,1868,1871,3,310,155,0,1869,1871,
  	5,132,0,0,1870,1868,1,0,0,0,1870,1869,1,0,0,0,1871,329,1,0,0,0,1872,1873,
  	5,52,0,0,1873,1874,3,378,189,0,1874,331,1,0,0,0,1875,1879,5,52,0,0,1876,
  	1877,5,4,0,0,1877,1880,5,132,0,0,1878,1880,5,140,0,0,1879,1876,1,0,0,
  	0,1879,1878,1,0,0,0,1880,333,1,0,0,0,1881,1882,5,68,0,0,1882,1883,5,102,
  	0,0,1883,1884,3,336,168,0,1884,1885,5,103,0,0,1885,1886,3,122,61,0,1886,
  	335,1,0,0,0,1887,1892,3,338,169,0,1888,1889,5,122,0,0,1889,1891,3,338,
  	169,0,1890,1888,1,0,0,0,1891,1894,1,0,0,0,1892,1890,1,0,0,0,1892,1893,
  	1,0,0,0,1893,337,1,0,0,0,1894,1892,1,0,0,0,1895,1898,3,340,170,0,1896,
  	1898,3,262,131,0,1897,1895,1,0,0,0,1897,1896,1,0,0,0,1898,339,1,0,0,0,
  	1899,1900,5,68,0,0,1900,1901,5,102,0,0,1901,1902,3,336,168,0,1902,1903,
  	5,103,0,0,1903,1905,1,0,0,0,1904,1899,1,0,0,0,1904,1905,1,0,0,0,1905,
  	1906,1,0,0,0,1906,1909,5,21,0,0,1907,1909,5,76,0,0,1908,1904,1,0,0,0,
  	1908,1907,1,0,0,0,1909,1921,1,0,0,0,1910,1912,5,131,0,0,1911,1910,1,0,
  	0,0,1911,1912,1,0,0,0,1912,1914,1,0,0,0,1913,1915,5,132,0,0,1914,1913,
  	1,0,0,0,1914,1915,1,0,0,0,1915,1922,1,0,0,0,1916,1918,5,132,0,0,1917,
  	1916,1,0,0,0,1917,1918,1,0,0,0,1918,1919,1,0,0,0,1919,1920,5,101,0,0,
  	1920,1922,3,246,123,0,1921,1911,1,0,0,0,1921,1917,1,0,0,0,1922,341,1,
  	0,0,0,1923,1924,3,346,173,0,1924,1926,5,102,0,0,1925,1927,3,348,174,0,
  	1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1928,1,0,0,0,1928,1929,5,103,
  	0,0,1929,343,1,0,0,0,1930,1942,3,342,171,0,1931,1934,3,330,165,0,1932,
  	1934,3,332,166,0,1933,1931,1,0,0,0,1933,1932,1,0,0,0,1934,1935,1,0,0,
  	0,1935,1937,5,102,0,0,1936,1938,3,348,174,0,1937,1936,1,0,0,0,1937,1938,
  	1,0,0,0,1938,1939,1,0,0,0,1939,1940,5,103,0,0,1940,1942,1,0,0,0,1941,
  	1930,1,0,0,0,1941,1933,1,0,0,0,1942,345,1,0,0,0,1943,1944,5,132,0,0,1944,
  	347,1,0,0,0,1945,1947,3,350,175,0,1946,1948,5,131,0,0,1947,1946,1,0,0,
  	0,1947,1948,1,0,0,0,1948,1956,1,0,0,0,1949,1950,5,122,0,0,1950,1952,3,
  	350,175,0,1951,1953,5,131,0,0,1952,1951,1,0,0,0,1952,1953,1,0,0,0,1953,
  	1955,1,0,0,0,1954,1949,1,0,0,0,1955,1958,1,0,0,0,1956,1954,1,0,0,0,1956,
  	1957,1,0,0,0,1957,349,1,0,0,0,1958,1956,1,0,0,0,1959,1963,3,246,123,0,
  	1960,1963,3,92,46,0,1961,1963,3,4,2,0,1962,1959,1,0,0,0,1962,1960,1,0,
  	0,0,1962,1961,1,0,0,0,1963,351,1,0,0,0,1964,1965,5,76,0,0,1965,1971,3,
  	10,5,0,1966,1972,5,132,0,0,1967,1969,5,68,0,0,1968,1967,1,0,0,0,1968,
  	1969,1,0,0,0,1969,1970,1,0,0,0,1970,1972,3,342,171,0,1971,1966,1,0,0,
  	0,1971,1968,1,0,0,0,1972,353,1,0,0,0,1973,1975,5,36,0,0,1974,1973,1,0,
  	0,0,1974,1975,1,0,0,0,1975,1976,1,0,0,0,1976,1977,5,68,0,0,1977,1978,
  	3,122,61,0,1978,355,1,0,0,0,1979,1980,5,68,0,0,1980,1981,5,102,0,0,1981,
  	1982,5,103,0,0,1982,1983,3,122,61,0,1983,357,1,0,0,0,1984,1985,5,73,0,
  	0,1985,1986,3,100,50,0,1986,1987,3,362,181,0,1987,359,1,0,0,0,1988,1990,
  	5,73,0,0,1989,1991,3,322,161,0,1990,1989,1,0,0,0,1990,1991,1,0,0,0,1991,
  	1992,1,0,0,0,1992,1993,3,100,50,0,1993,1994,3,362,181,0,1994,361,1,0,
  	0,0,1995,1997,3,364,182,0,1996,1995,1,0,0,0,1997,1998,1,0,0,0,1998,1996,
  	1,0,0,0,1998,1999,1,0,0,0,1999,363,1,0,0,0,2000,2001,5,17,0,0,2001,2002,
  	5,85,0,0,2002,2003,3,366,183,0,2003,2004,5,86,0,0,2004,2005,3,100,50,
  	0,2005,365,1,0,0,0,2006,2008,3,204,102,0,2007,2006,1,0,0,0,2007,2008,
  	1,0,0,0,2008,2009,1,0,0,0,2009,2012,3,150,75,0,2010,2013,3,226,113,0,
  	2011,2013,3,248,124,0,2012,2010,1,0,0,0,2012,2011,1,0,0,0,2012,2013,1,
  	0,0,0,2013,2016,1,0,0,0,2014,2016,5,131,0,0,2015,2007,1,0,0,0,2015,2014,
  	1,0,0,0,2016,367,1,0,0,0,2017,2019,5,71,0,0,2018,2020,3,86,43,0,2019,
  	2018,1,0,0,0,2019,2020,1,0,0,0,2020,369,1,0,0,0,2021,2024,3,372,186,0,
  	2022,2024,3,376,188,0,2023,2021,1,0,0,0,2023,2022,1,0,0,0,2024,371,1,
  	0,0,0,2025,2026,5,71,0,0,2026,2028,5,85,0,0,2027,2029,3,374,187,0,2028,
  	2027,1,0,0,0,2028,2029,1,0,0,0,2029,2030,1,0,0,0,2030,2031,5,86,0,0,2031,
  	373,1,0,0,0,2032,2034,3,246,123,0,2033,2035,5,131,0,0,2034,2033,1,0,0,
  	0,2034,2035,1,0,0,0,2035,2043,1,0,0,0,2036,2037,5,122,0,0,2037,2039,3,
  	246,123,0,2038,2040,5,131,0,0,2039,2038,1,0,0,0,2039,2040,1,0,0,0,2040,
  	2042,1,0,0,0,2041,2036,1,0,0,0,2042,2045,1,0,0,0,2043,2041,1,0,0,0,2043,
  	2044,1,0,0,0,2044,375,1,0,0,0,2045,2043,1,0,0,0,2046,2047,5,50,0,0,2047,
  	2048,5,85,0,0,2048,2049,3,92,46,0,2049,2050,5,86,0,0,2050,2053,1,0,0,
  	0,2051,2053,5,50,0,0,2052,2046,1,0,0,0,2052,2051,1,0,0,0,2053,377,1,0,
  	0,0,2054,2057,5,49,0,0,2055,2056,5,87,0,0,2056,2058,5,88,0,0,2057,2055,
  	1,0,0,0,2057,2058,1,0,0,0,2058,2106,1,0,0,0,2059,2062,5,28,0,0,2060,2061,
  	5,87,0,0,2061,2063,5,88,0,0,2062,2060,1,0,0,0,2062,2063,1,0,0,0,2063,
  	2106,1,0,0,0,2064,2106,5,91,0,0,2065,2106,5,92,0,0,2066,2106,5,93,0,0,
  	2067,2106,5,94,0,0,2068,2106,5,95,0,0,2069,2106,5,96,0,0,2070,2106,5,
  	97,0,0,2071,2106,5,98,0,0,2072,2106,5,99,0,0,2073,2106,5,100,0,0,2074,
  	2106,5,101,0,0,2075,2106,5,103,0,0,2076,2106,5,102,0,0,2077,2106,5,117,
  	0,0,2078,2106,5,104,0,0,2079,2106,5,105,0,0,2080,2106,5,106,0,0,2081,
  	2106,5,108,0,0,2082,2106,5,109,0,0,2083,2106,5,110,0,0,2084,2106,5,111,
  	0,0,2085,2086,5,102,0,0,2086,2106,5,102,0,0,2087,2088,5,103,0,0,2088,
  	2106,5,103,0,0,2089,2106,5,113,0,0,2090,2106,5,112,0,0,2091,2106,5,114,
  	0,0,2092,2106,5,115,0,0,2093,2106,5,116,0,0,2094,2106,5,118,0,0,2095,
  	2106,5,119,0,0,2096,2106,5,120,0,0,2097,2106,5,121,0,0,2098,2106,5,122,
  	0,0,2099,2106,5,123,0,0,2100,2106,5,124,0,0,2101,2102,5,85,0,0,2102,2106,
  	5,86,0,0,2103,2104,5,87,0,0,2104,2106,5,88,0,0,2105,2054,1,0,0,0,2105,
  	2059,1,0,0,0,2105,2064,1,0,0,0,2105,2065,1,0,0,0,2105,2066,1,0,0,0,2105,
  	2067,1,0,0,0,2105,2068,1,0,0,0,2105,2069,1,0,0,0,2105,2070,1,0,0,0,2105,
  	2071,1,0,0,0,2105,2072,1,0,0,0,2105,2073,1,0,0,0,2105,2074,1,0,0,0,2105,
  	2075,1,0,0,0,2105,2076,1,0,0,0,2105,2077,1,0,0,0,2105,2078,1,0,0,0,2105,
  	2079,1,0,0,0,2105,2080,1,0,0,0,2105,2081,1,0,0,0,2105,2082,1,0,0,0,2105,
  	2083,1,0,0,0,2105,2084,1,0,0,0,2105,2085,1,0,0,0,2105,2087,1,0,0,0,2105,
  	2089,1,0,0,0,2105,2090,1,0,0,0,2105,2091,1,0,0,0,2105,2092,1,0,0,0,2105,
  	2093,1,0,0,0,2105,2094,1,0,0,0,2105,2095,1,0,0,0,2105,2096,1,0,0,0,2105,
  	2097,1,0,0,0,2105,2098,1,0,0,0,2105,2099,1,0,0,0,2105,2100,1,0,0,0,2105,
  	2101,1,0,0,0,2105,2103,1,0,0,0,2106,379,1,0,0,0,2107,2108,7,22,0,0,2108,
  	381,1,0,0,0,306,383,390,399,403,412,415,419,427,434,437,442,447,453,461,
  	463,472,476,480,483,487,490,497,501,504,507,510,516,520,524,538,542,548,
  	555,561,565,569,571,579,584,597,604,616,626,631,635,642,645,653,657,660,
  	667,674,678,683,687,690,695,710,717,725,733,742,749,756,764,772,780,788,
  	796,804,813,821,830,838,846,848,851,857,863,869,876,885,893,897,904,906,
  	926,930,936,941,945,948,955,962,966,975,986,996,1001,1008,1011,1016,1021,
  	1042,1047,1050,1061,1067,1072,1075,1080,1083,1090,1099,1104,1107,1111,
  	1115,1119,1124,1129,1135,1141,1147,1153,1159,1162,1168,1172,1176,1179,
  	1187,1189,1195,1198,1201,1204,1208,1212,1218,1228,1234,1240,1245,1250,
  	1254,1267,1273,1277,1283,1288,1303,1307,1312,1317,1322,1328,1331,1340,
  	1344,1349,1353,1359,1366,1383,1385,1392,1397,1404,1408,1412,1420,1426,
  	1432,1436,1438,1442,1447,1451,1454,1457,1460,1465,1469,1472,1476,1479,
  	1481,1486,1493,1499,1503,1509,1515,1518,1520,1526,1530,1536,1543,1547,
  	1549,1553,1559,1571,1575,1577,1581,1586,1589,1596,1600,1605,1607,1611,
  	1614,1617,1621,1626,1633,1640,1645,1649,1653,1658,1662,1668,1670,1676,
  	1681,1687,1691,1693,1696,1700,1704,1706,1708,1711,1723,1725,1728,1731,
  	1734,1743,1750,1755,1758,1761,1763,1766,1769,1773,1778,1791,1796,1800,
  	1804,1809,1814,1818,1821,1825,1836,1840,1847,1852,1856,1862,1866,1870,
  	1879,1892,1897,1904,1908,1911,1914,1917,1921,1926,1933,1937,1941,1947,
  	1952,1956,1962,1968,1971,1974,1990,1998,2007,2012,2015,2019,2023,2028,
  	2034,2039,2043,2052,2057,2062,2105
  };
  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));

  antlr4::atn::ATNDeserializer deserializer;
  staticData->atn = deserializer.deserialize(staticData->serializedATN);

  const size_t count = staticData->atn->getNumberOfDecisions();
  staticData->decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
  }
  cpp14parserParserStaticData = staticData.release();
}

}

CPP14Parser::CPP14Parser(TokenStream *input) : CPP14Parser(input, antlr4::atn::ParserATNSimulatorOptions()) {}

CPP14Parser::CPP14Parser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
  CPP14Parser::initialize();
  _interpreter = new atn::ParserATNSimulator(this, *cpp14parserParserStaticData->atn, cpp14parserParserStaticData->decisionToDFA, cpp14parserParserStaticData->sharedContextCache, options);
}

CPP14Parser::~CPP14Parser() {
  delete _interpreter;
}

const atn::ATN& CPP14Parser::getATN() const {
  return *cpp14parserParserStaticData->atn;
}

std::string CPP14Parser::getGrammarFileName() const {
  return "CPP14Parser.g4";
}

const std::vector<std::string>& CPP14Parser::getRuleNames() const {
  return cpp14parserParserStaticData->ruleNames;
}

const dfa::Vocabulary& CPP14Parser::getVocabulary() const {
  return cpp14parserParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView CPP14Parser::getSerializedATN() const {
  return cpp14parserParserStaticData->serializedATN;
}


//----------------- TranslationUnitContext ------------------------------------------------------------------

CPP14Parser::TranslationUnitContext::TranslationUnitContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TranslationUnitContext::EOF() {
  return getToken(CPP14Parser::EOF, 0);
}

CPP14Parser::DeclarationseqContext* CPP14Parser::TranslationUnitContext::declarationseq() {
  return getRuleContext<CPP14Parser::DeclarationseqContext>(0);
}


size_t CPP14Parser::TranslationUnitContext::getRuleIndex() const {
  return CPP14Parser::RuleTranslationUnit;
}


std::any CPP14Parser::TranslationUnitContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTranslationUnit(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TranslationUnitContext* CPP14Parser::translationUnit() {
  TranslationUnitContext *_localctx = _tracker.createInstance<TranslationUnitContext>(_ctx, getState());
  enterRule(_localctx, 0, CPP14Parser::RuleTranslationUnit);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(383);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1543754443169808157) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 459384754220313597) != 0) {
      setState(382);
      declarationseq();
    }
    setState(385);
    match(CPP14Parser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrimaryExpressionContext ------------------------------------------------------------------

CPP14Parser::PrimaryExpressionContext::PrimaryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::LiteralContext *> CPP14Parser::PrimaryExpressionContext::literal() {
  return getRuleContexts<CPP14Parser::LiteralContext>();
}

CPP14Parser::LiteralContext* CPP14Parser::PrimaryExpressionContext::literal(size_t i) {
  return getRuleContext<CPP14Parser::LiteralContext>(i);
}

tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::This() {
  return getToken(CPP14Parser::This, 0);
}

tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::PrimaryExpressionContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::PrimaryExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::IdExpressionContext* CPP14Parser::PrimaryExpressionContext::idExpression() {
  return getRuleContext<CPP14Parser::IdExpressionContext>(0);
}

CPP14Parser::LambdaExpressionContext* CPP14Parser::PrimaryExpressionContext::lambdaExpression() {
  return getRuleContext<CPP14Parser::LambdaExpressionContext>(0);
}


size_t CPP14Parser::PrimaryExpressionContext::getRuleIndex() const {
  return CPP14Parser::RulePrimaryExpression;
}


std::any CPP14Parser::PrimaryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPrimaryExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PrimaryExpressionContext* CPP14Parser::primaryExpression() {
  PrimaryExpressionContext *_localctx = _tracker.createInstance<PrimaryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 2, CPP14Parser::RulePrimaryExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(399);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::IntegerLiteral:
      case CPP14Parser::CharacterLiteral:
      case CPP14Parser::FloatingLiteral:
      case CPP14Parser::StringLiteral:
      case CPP14Parser::BooleanLiteral:
      case CPP14Parser::PointerLiteral:
      case CPP14Parser::UserDefinedLiteral: {
        enterOuterAlt(_localctx, 1);
        setState(388); 
        _errHandler->sync(this);
        alt = 1;
        do {
          switch (alt) {
            case 1: {
                  setState(387);
                  literal();
                  break;
                }

          default:
            throw NoViableAltException(this);
          }
          setState(390); 
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx);
        } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
        break;
      }

      case CPP14Parser::This: {
        enterOuterAlt(_localctx, 2);
        setState(392);
        match(CPP14Parser::This);
        break;
      }

      case CPP14Parser::LeftParen: {
        enterOuterAlt(_localctx, 3);
        setState(393);
        match(CPP14Parser::LeftParen);
        setState(394);
        expression();
        setState(395);
        match(CPP14Parser::RightParen);
        break;
      }

      case CPP14Parser::Decltype:
      case CPP14Parser::Operator:
      case CPP14Parser::Tilde:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 4);
        setState(397);
        idExpression();
        break;
      }

      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 5);
        setState(398);
        lambdaExpression();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdExpressionContext ------------------------------------------------------------------

CPP14Parser::IdExpressionContext::IdExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::UnqualifiedIdContext* CPP14Parser::IdExpressionContext::unqualifiedId() {
  return getRuleContext<CPP14Parser::UnqualifiedIdContext>(0);
}

CPP14Parser::QualifiedIdContext* CPP14Parser::IdExpressionContext::qualifiedId() {
  return getRuleContext<CPP14Parser::QualifiedIdContext>(0);
}


size_t CPP14Parser::IdExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleIdExpression;
}


std::any CPP14Parser::IdExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitIdExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::IdExpressionContext* CPP14Parser::idExpression() {
  IdExpressionContext *_localctx = _tracker.createInstance<IdExpressionContext>(_ctx, getState());
  enterRule(_localctx, 4, CPP14Parser::RuleIdExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(403);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(401);
      unqualifiedId();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(402);
      qualifiedId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnqualifiedIdContext ------------------------------------------------------------------

CPP14Parser::UnqualifiedIdContext::UnqualifiedIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::UnqualifiedIdContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::OperatorFunctionIdContext* CPP14Parser::UnqualifiedIdContext::operatorFunctionId() {
  return getRuleContext<CPP14Parser::OperatorFunctionIdContext>(0);
}

CPP14Parser::ConversionFunctionIdContext* CPP14Parser::UnqualifiedIdContext::conversionFunctionId() {
  return getRuleContext<CPP14Parser::ConversionFunctionIdContext>(0);
}

CPP14Parser::LiteralOperatorIdContext* CPP14Parser::UnqualifiedIdContext::literalOperatorId() {
  return getRuleContext<CPP14Parser::LiteralOperatorIdContext>(0);
}

tree::TerminalNode* CPP14Parser::UnqualifiedIdContext::Tilde() {
  return getToken(CPP14Parser::Tilde, 0);
}

CPP14Parser::ClassNameContext* CPP14Parser::UnqualifiedIdContext::className() {
  return getRuleContext<CPP14Parser::ClassNameContext>(0);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::UnqualifiedIdContext::decltypeSpecifier() {
  return getRuleContext<CPP14Parser::DecltypeSpecifierContext>(0);
}

CPP14Parser::TemplateIdContext* CPP14Parser::UnqualifiedIdContext::templateId() {
  return getRuleContext<CPP14Parser::TemplateIdContext>(0);
}


size_t CPP14Parser::UnqualifiedIdContext::getRuleIndex() const {
  return CPP14Parser::RuleUnqualifiedId;
}


std::any CPP14Parser::UnqualifiedIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitUnqualifiedId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::UnqualifiedIdContext* CPP14Parser::unqualifiedId() {
  UnqualifiedIdContext *_localctx = _tracker.createInstance<UnqualifiedIdContext>(_ctx, getState());
  enterRule(_localctx, 6, CPP14Parser::RuleUnqualifiedId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(415);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 5, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(405);
      match(CPP14Parser::Identifier);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(406);
      operatorFunctionId();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(407);
      conversionFunctionId();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(408);
      literalOperatorId();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(409);
      match(CPP14Parser::Tilde);
      setState(412);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::Identifier: {
          setState(410);
          className();
          break;
        }

        case CPP14Parser::Decltype: {
          setState(411);
          decltypeSpecifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(414);
      templateId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QualifiedIdContext ------------------------------------------------------------------

CPP14Parser::QualifiedIdContext::QualifiedIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::QualifiedIdContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

CPP14Parser::UnqualifiedIdContext* CPP14Parser::QualifiedIdContext::unqualifiedId() {
  return getRuleContext<CPP14Parser::UnqualifiedIdContext>(0);
}

tree::TerminalNode* CPP14Parser::QualifiedIdContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}


size_t CPP14Parser::QualifiedIdContext::getRuleIndex() const {
  return CPP14Parser::RuleQualifiedId;
}


std::any CPP14Parser::QualifiedIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitQualifiedId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::QualifiedIdContext* CPP14Parser::qualifiedId() {
  QualifiedIdContext *_localctx = _tracker.createInstance<QualifiedIdContext>(_ctx, getState());
  enterRule(_localctx, 8, CPP14Parser::RuleQualifiedId);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(417);
    nestedNameSpecifier(0);
    setState(419);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Template) {
      setState(418);
      match(CPP14Parser::Template);
    }
    setState(421);
    unqualifiedId();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NestedNameSpecifierContext ------------------------------------------------------------------

CPP14Parser::NestedNameSpecifierContext::NestedNameSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

CPP14Parser::TheTypeNameContext* CPP14Parser::NestedNameSpecifierContext::theTypeName() {
  return getRuleContext<CPP14Parser::TheTypeNameContext>(0);
}

CPP14Parser::NamespaceNameContext* CPP14Parser::NestedNameSpecifierContext::namespaceName() {
  return getRuleContext<CPP14Parser::NamespaceNameContext>(0);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::NestedNameSpecifierContext::decltypeSpecifier() {
  return getRuleContext<CPP14Parser::DecltypeSpecifierContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::NestedNameSpecifierContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::NestedNameSpecifierContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

tree::TerminalNode* CPP14Parser::NestedNameSpecifierContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}


size_t CPP14Parser::NestedNameSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleNestedNameSpecifier;
}


std::any CPP14Parser::NestedNameSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNestedNameSpecifier(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::NestedNameSpecifierContext* CPP14Parser::nestedNameSpecifier() {
   return nestedNameSpecifier(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::nestedNameSpecifier(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::NestedNameSpecifierContext *_localctx = _tracker.createInstance<NestedNameSpecifierContext>(_ctx, parentState);
  CPP14Parser::NestedNameSpecifierContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 10;
  enterRecursionRule(_localctx, 10, CPP14Parser::RuleNestedNameSpecifier, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(427);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      setState(424);
      theTypeName();
      break;
    }

    case 2: {
      setState(425);
      namespaceName();
      break;
    }

    case 3: {
      setState(426);
      decltypeSpecifier();
      break;
    }

    default:
      break;
    }
    setState(429);
    match(CPP14Parser::Doublecolon);
    _ctx->stop = _input->LT(-1);
    setState(442);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<NestedNameSpecifierContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleNestedNameSpecifier);
        setState(431);

        if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
        setState(437);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
        case 1: {
          setState(432);
          match(CPP14Parser::Identifier);
          break;
        }

        case 2: {
          setState(434);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CPP14Parser::Template) {
            setState(433);
            match(CPP14Parser::Template);
          }
          setState(436);
          simpleTemplateId();
          break;
        }

        default:
          break;
        }
        setState(439);
        match(CPP14Parser::Doublecolon); 
      }
      setState(444);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- LambdaExpressionContext ------------------------------------------------------------------

CPP14Parser::LambdaExpressionContext::LambdaExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::LambdaIntroducerContext* CPP14Parser::LambdaExpressionContext::lambdaIntroducer() {
  return getRuleContext<CPP14Parser::LambdaIntroducerContext>(0);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::LambdaExpressionContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}

CPP14Parser::LambdaDeclaratorContext* CPP14Parser::LambdaExpressionContext::lambdaDeclarator() {
  return getRuleContext<CPP14Parser::LambdaDeclaratorContext>(0);
}


size_t CPP14Parser::LambdaExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleLambdaExpression;
}


std::any CPP14Parser::LambdaExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLambdaExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LambdaExpressionContext* CPP14Parser::lambdaExpression() {
  LambdaExpressionContext *_localctx = _tracker.createInstance<LambdaExpressionContext>(_ctx, getState());
  enterRule(_localctx, 12, CPP14Parser::RuleLambdaExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(445);
    lambdaIntroducer();
    setState(447);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::LeftParen) {
      setState(446);
      lambdaDeclarator();
    }
    setState(449);
    compoundStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LambdaIntroducerContext ------------------------------------------------------------------

CPP14Parser::LambdaIntroducerContext::LambdaIntroducerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LambdaIntroducerContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::LambdaIntroducerContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

CPP14Parser::LambdaCaptureContext* CPP14Parser::LambdaIntroducerContext::lambdaCapture() {
  return getRuleContext<CPP14Parser::LambdaCaptureContext>(0);
}


size_t CPP14Parser::LambdaIntroducerContext::getRuleIndex() const {
  return CPP14Parser::RuleLambdaIntroducer;
}


std::any CPP14Parser::LambdaIntroducerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLambdaIntroducer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LambdaIntroducerContext* CPP14Parser::lambdaIntroducer() {
  LambdaIntroducerContext *_localctx = _tracker.createInstance<LambdaIntroducerContext>(_ctx, getState());
  enterRule(_localctx, 14, CPP14Parser::RuleLambdaIntroducer);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(451);
    match(CPP14Parser::LeftBracket);
    setState(453);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 69) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 69)) & -9223372032291373055) != 0) {
      setState(452);
      lambdaCapture();
    }
    setState(455);
    match(CPP14Parser::RightBracket);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LambdaCaptureContext ------------------------------------------------------------------

CPP14Parser::LambdaCaptureContext::LambdaCaptureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::CaptureListContext* CPP14Parser::LambdaCaptureContext::captureList() {
  return getRuleContext<CPP14Parser::CaptureListContext>(0);
}

CPP14Parser::CaptureDefaultContext* CPP14Parser::LambdaCaptureContext::captureDefault() {
  return getRuleContext<CPP14Parser::CaptureDefaultContext>(0);
}

tree::TerminalNode* CPP14Parser::LambdaCaptureContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}


size_t CPP14Parser::LambdaCaptureContext::getRuleIndex() const {
  return CPP14Parser::RuleLambdaCapture;
}


std::any CPP14Parser::LambdaCaptureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLambdaCapture(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LambdaCaptureContext* CPP14Parser::lambdaCapture() {
  LambdaCaptureContext *_localctx = _tracker.createInstance<LambdaCaptureContext>(_ctx, getState());
  enterRule(_localctx, 16, CPP14Parser::RuleLambdaCapture);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(463);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(457);
      captureList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(458);
      captureDefault();
      setState(461);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Comma) {
        setState(459);
        match(CPP14Parser::Comma);
        setState(460);
        captureList();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaptureDefaultContext ------------------------------------------------------------------

CPP14Parser::CaptureDefaultContext::CaptureDefaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::CaptureDefaultContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::CaptureDefaultContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}


size_t CPP14Parser::CaptureDefaultContext::getRuleIndex() const {
  return CPP14Parser::RuleCaptureDefault;
}


std::any CPP14Parser::CaptureDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCaptureDefault(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CaptureDefaultContext* CPP14Parser::captureDefault() {
  CaptureDefaultContext *_localctx = _tracker.createInstance<CaptureDefaultContext>(_ctx, getState());
  enterRule(_localctx, 18, CPP14Parser::RuleCaptureDefault);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(465);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::And

    || _la == CPP14Parser::Assign)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaptureListContext ------------------------------------------------------------------

CPP14Parser::CaptureListContext::CaptureListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::CaptureContext *> CPP14Parser::CaptureListContext::capture() {
  return getRuleContexts<CPP14Parser::CaptureContext>();
}

CPP14Parser::CaptureContext* CPP14Parser::CaptureListContext::capture(size_t i) {
  return getRuleContext<CPP14Parser::CaptureContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::CaptureListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::CaptureListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}

tree::TerminalNode* CPP14Parser::CaptureListContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}


size_t CPP14Parser::CaptureListContext::getRuleIndex() const {
  return CPP14Parser::RuleCaptureList;
}


std::any CPP14Parser::CaptureListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCaptureList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CaptureListContext* CPP14Parser::captureList() {
  CaptureListContext *_localctx = _tracker.createInstance<CaptureListContext>(_ctx, getState());
  enterRule(_localctx, 20, CPP14Parser::RuleCaptureList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(467);
    capture();
    setState(472);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(468);
      match(CPP14Parser::Comma);
      setState(469);
      capture();
      setState(474);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(476);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(475);
      match(CPP14Parser::Ellipsis);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaptureContext ------------------------------------------------------------------

CPP14Parser::CaptureContext::CaptureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::SimpleCaptureContext* CPP14Parser::CaptureContext::simpleCapture() {
  return getRuleContext<CPP14Parser::SimpleCaptureContext>(0);
}

CPP14Parser::InitcaptureContext* CPP14Parser::CaptureContext::initcapture() {
  return getRuleContext<CPP14Parser::InitcaptureContext>(0);
}


size_t CPP14Parser::CaptureContext::getRuleIndex() const {
  return CPP14Parser::RuleCapture;
}


std::any CPP14Parser::CaptureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCapture(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CaptureContext* CPP14Parser::capture() {
  CaptureContext *_localctx = _tracker.createInstance<CaptureContext>(_ctx, getState());
  enterRule(_localctx, 22, CPP14Parser::RuleCapture);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(480);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(478);
      simpleCapture();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(479);
      initcapture();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleCaptureContext ------------------------------------------------------------------

CPP14Parser::SimpleCaptureContext::SimpleCaptureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::SimpleCaptureContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::SimpleCaptureContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::SimpleCaptureContext::This() {
  return getToken(CPP14Parser::This, 0);
}


size_t CPP14Parser::SimpleCaptureContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleCapture;
}


std::any CPP14Parser::SimpleCaptureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleCapture(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleCaptureContext* CPP14Parser::simpleCapture() {
  SimpleCaptureContext *_localctx = _tracker.createInstance<SimpleCaptureContext>(_ctx, getState());
  enterRule(_localctx, 24, CPP14Parser::RuleSimpleCapture);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(487);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::And:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(483);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::And) {
          setState(482);
          match(CPP14Parser::And);
        }
        setState(485);
        match(CPP14Parser::Identifier);
        break;
      }

      case CPP14Parser::This: {
        enterOuterAlt(_localctx, 2);
        setState(486);
        match(CPP14Parser::This);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitcaptureContext ------------------------------------------------------------------

CPP14Parser::InitcaptureContext::InitcaptureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::InitcaptureContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::InitializerContext* CPP14Parser::InitcaptureContext::initializer() {
  return getRuleContext<CPP14Parser::InitializerContext>(0);
}

tree::TerminalNode* CPP14Parser::InitcaptureContext::And() {
  return getToken(CPP14Parser::And, 0);
}


size_t CPP14Parser::InitcaptureContext::getRuleIndex() const {
  return CPP14Parser::RuleInitcapture;
}


std::any CPP14Parser::InitcaptureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitcapture(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitcaptureContext* CPP14Parser::initcapture() {
  InitcaptureContext *_localctx = _tracker.createInstance<InitcaptureContext>(_ctx, getState());
  enterRule(_localctx, 26, CPP14Parser::RuleInitcapture);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(490);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::And) {
      setState(489);
      match(CPP14Parser::And);
    }
    setState(492);
    match(CPP14Parser::Identifier);
    setState(493);
    initializer();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LambdaDeclaratorContext ------------------------------------------------------------------

CPP14Parser::LambdaDeclaratorContext::LambdaDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::LambdaDeclaratorContext::parameterDeclarationClause() {
  return getRuleContext<CPP14Parser::ParameterDeclarationClauseContext>(0);
}

tree::TerminalNode* CPP14Parser::LambdaDeclaratorContext::Mutable() {
  return getToken(CPP14Parser::Mutable, 0);
}

CPP14Parser::ExceptionSpecificationContext* CPP14Parser::LambdaDeclaratorContext::exceptionSpecification() {
  return getRuleContext<CPP14Parser::ExceptionSpecificationContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::LambdaDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::TrailingReturnTypeContext* CPP14Parser::LambdaDeclaratorContext::trailingReturnType() {
  return getRuleContext<CPP14Parser::TrailingReturnTypeContext>(0);
}


size_t CPP14Parser::LambdaDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleLambdaDeclarator;
}


std::any CPP14Parser::LambdaDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLambdaDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LambdaDeclaratorContext* CPP14Parser::lambdaDeclarator() {
  LambdaDeclaratorContext *_localctx = _tracker.createInstance<LambdaDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 28, CPP14Parser::RuleLambdaDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(495);
    match(CPP14Parser::LeftParen);
    setState(497);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1237504995584196377) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 297237575406461917) != 0) {
      setState(496);
      parameterDeclarationClause();
    }
    setState(499);
    match(CPP14Parser::RightParen);
    setState(501);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Mutable) {
      setState(500);
      match(CPP14Parser::Mutable);
    }
    setState(504);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Noexcept

    || _la == CPP14Parser::Throw) {
      setState(503);
      exceptionSpecification();
    }
    setState(507);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(506);
      attributeSpecifierSeq();
    }
    setState(510);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Arrow) {
      setState(509);
      trailingReturnType();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PostfixExpressionContext ------------------------------------------------------------------

CPP14Parser::PostfixExpressionContext::PostfixExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PrimaryExpressionContext* CPP14Parser::PostfixExpressionContext::primaryExpression() {
  return getRuleContext<CPP14Parser::PrimaryExpressionContext>(0);
}

CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::PostfixExpressionContext::simpleTypeSpecifier() {
  return getRuleContext<CPP14Parser::SimpleTypeSpecifierContext>(0);
}

CPP14Parser::TypeNameSpecifierContext* CPP14Parser::PostfixExpressionContext::typeNameSpecifier() {
  return getRuleContext<CPP14Parser::TypeNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::PostfixExpressionContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}

CPP14Parser::ExpressionListContext* CPP14Parser::PostfixExpressionContext::expressionList() {
  return getRuleContext<CPP14Parser::ExpressionListContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::PostfixExpressionContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::PostfixExpressionContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Dynamic_cast() {
  return getToken(CPP14Parser::Dynamic_cast, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Static_cast() {
  return getToken(CPP14Parser::Static_cast, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Reinterpret_cast() {
  return getToken(CPP14Parser::Reinterpret_cast, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Const_cast() {
  return getToken(CPP14Parser::Const_cast, 0);
}

CPP14Parser::TypeIdOfTheTypeIdContext* CPP14Parser::PostfixExpressionContext::typeIdOfTheTypeId() {
  return getRuleContext<CPP14Parser::TypeIdOfTheTypeIdContext>(0);
}

CPP14Parser::PostfixExpressionContext* CPP14Parser::PostfixExpressionContext::postfixExpression() {
  return getRuleContext<CPP14Parser::PostfixExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Dot() {
  return getToken(CPP14Parser::Dot, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Arrow() {
  return getToken(CPP14Parser::Arrow, 0);
}

CPP14Parser::IdExpressionContext* CPP14Parser::PostfixExpressionContext::idExpression() {
  return getRuleContext<CPP14Parser::IdExpressionContext>(0);
}

CPP14Parser::PseudoDestructorNameContext* CPP14Parser::PostfixExpressionContext::pseudoDestructorName() {
  return getRuleContext<CPP14Parser::PseudoDestructorNameContext>(0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::PlusPlus() {
  return getToken(CPP14Parser::PlusPlus, 0);
}

tree::TerminalNode* CPP14Parser::PostfixExpressionContext::MinusMinus() {
  return getToken(CPP14Parser::MinusMinus, 0);
}


size_t CPP14Parser::PostfixExpressionContext::getRuleIndex() const {
  return CPP14Parser::RulePostfixExpression;
}


std::any CPP14Parser::PostfixExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPostfixExpression(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::PostfixExpressionContext* CPP14Parser::postfixExpression() {
   return postfixExpression(0);
}

CPP14Parser::PostfixExpressionContext* CPP14Parser::postfixExpression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::PostfixExpressionContext *_localctx = _tracker.createInstance<PostfixExpressionContext>(_ctx, parentState);
  CPP14Parser::PostfixExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 30;
  enterRecursionRule(_localctx, 30, CPP14Parser::RulePostfixExpression, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(542);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
    case 1: {
      setState(513);
      primaryExpression();
      break;
    }

    case 2: {
      setState(516);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::Auto:
        case CPP14Parser::Bool:
        case CPP14Parser::Char:
        case CPP14Parser::Char16:
        case CPP14Parser::Char32:
        case CPP14Parser::Decltype:
        case CPP14Parser::Double:
        case CPP14Parser::Float:
        case CPP14Parser::Int:
        case CPP14Parser::Long:
        case CPP14Parser::Short:
        case CPP14Parser::Signed:
        case CPP14Parser::Unsigned:
        case CPP14Parser::Void:
        case CPP14Parser::Wchar:
        case CPP14Parser::Doublecolon:
        case CPP14Parser::Identifier: {
          setState(514);
          simpleTypeSpecifier();
          break;
        }

        case CPP14Parser::Typename_: {
          setState(515);
          typeNameSpecifier();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(524);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::LeftParen: {
          setState(518);
          match(CPP14Parser::LeftParen);
          setState(520);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 65)) & 4719772474400910417) != 0 || _la == CPP14Parser::Identifier) {
            setState(519);
            expressionList();
          }
          setState(522);
          match(CPP14Parser::RightParen);
          break;
        }

        case CPP14Parser::LeftBrace: {
          setState(523);
          bracedInitList();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 3: {
      setState(526);
      _la = _input->LA(1);
      if (!((((_la - 24) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 24)) & 2216203124865) != 0)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(527);
      match(CPP14Parser::Less);
      setState(528);
      theTypeId();
      setState(529);
      match(CPP14Parser::Greater);
      setState(530);
      match(CPP14Parser::LeftParen);
      setState(531);
      expression();
      setState(532);
      match(CPP14Parser::RightParen);
      break;
    }

    case 4: {
      setState(534);
      typeIdOfTheTypeId();
      setState(535);
      match(CPP14Parser::LeftParen);
      setState(538);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
      case 1: {
        setState(536);
        expression();
        break;
      }

      case 2: {
        setState(537);
        theTypeId();
        break;
      }

      default:
        break;
      }
      setState(540);
      match(CPP14Parser::RightParen);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(571);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(569);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<PostfixExpressionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePostfixExpression);
          setState(544);

          if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
          setState(545);
          match(CPP14Parser::LeftBracket);
          setState(548);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case CPP14Parser::IntegerLiteral:
            case CPP14Parser::CharacterLiteral:
            case CPP14Parser::FloatingLiteral:
            case CPP14Parser::StringLiteral:
            case CPP14Parser::BooleanLiteral:
            case CPP14Parser::PointerLiteral:
            case CPP14Parser::UserDefinedLiteral:
            case CPP14Parser::Alignof:
            case CPP14Parser::Auto:
            case CPP14Parser::Bool:
            case CPP14Parser::Char:
            case CPP14Parser::Char16:
            case CPP14Parser::Char32:
            case CPP14Parser::Const_cast:
            case CPP14Parser::Decltype:
            case CPP14Parser::Delete:
            case CPP14Parser::Double:
            case CPP14Parser::Dynamic_cast:
            case CPP14Parser::Float:
            case CPP14Parser::Int:
            case CPP14Parser::Long:
            case CPP14Parser::New:
            case CPP14Parser::Noexcept:
            case CPP14Parser::Operator:
            case CPP14Parser::Reinterpret_cast:
            case CPP14Parser::Short:
            case CPP14Parser::Signed:
            case CPP14Parser::Sizeof:
            case CPP14Parser::Static_cast:
            case CPP14Parser::This:
            case CPP14Parser::Throw:
            case CPP14Parser::Typeid_:
            case CPP14Parser::Typename_:
            case CPP14Parser::Unsigned:
            case CPP14Parser::Void:
            case CPP14Parser::Wchar:
            case CPP14Parser::LeftParen:
            case CPP14Parser::LeftBracket:
            case CPP14Parser::Plus:
            case CPP14Parser::Minus:
            case CPP14Parser::Star:
            case CPP14Parser::And:
            case CPP14Parser::Or:
            case CPP14Parser::Tilde:
            case CPP14Parser::Not:
            case CPP14Parser::PlusPlus:
            case CPP14Parser::MinusMinus:
            case CPP14Parser::Doublecolon:
            case CPP14Parser::Identifier: {
              setState(546);
              expression();
              break;
            }

            case CPP14Parser::LeftBrace: {
              setState(547);
              bracedInitList();
              break;
            }

          default:
            throw NoViableAltException(this);
          }
          setState(550);
          match(CPP14Parser::RightBracket);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<PostfixExpressionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePostfixExpression);
          setState(552);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(553);
          match(CPP14Parser::LeftParen);
          setState(555);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 65)) & 4719772474400910417) != 0 || _la == CPP14Parser::Identifier) {
            setState(554);
            expressionList();
          }
          setState(557);
          match(CPP14Parser::RightParen);
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<PostfixExpressionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePostfixExpression);
          setState(558);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(559);
          _la = _input->LA(1);
          if (!(_la == CPP14Parser::Arrow

          || _la == CPP14Parser::Dot)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(565);
          _errHandler->sync(this);
          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx)) {
          case 1: {
            setState(561);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CPP14Parser::Template) {
              setState(560);
              match(CPP14Parser::Template);
            }
            setState(563);
            idExpression();
            break;
          }

          case 2: {
            setState(564);
            pseudoDestructorName();
            break;
          }

          default:
            break;
          }
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<PostfixExpressionContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RulePostfixExpression);
          setState(567);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(568);
          _la = _input->LA(1);
          if (!(_la == CPP14Parser::PlusPlus

          || _la == CPP14Parser::MinusMinus)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        default:
          break;
        } 
      }
      setState(573);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- TypeIdOfTheTypeIdContext ------------------------------------------------------------------

CPP14Parser::TypeIdOfTheTypeIdContext::TypeIdOfTheTypeIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TypeIdOfTheTypeIdContext::Typeid_() {
  return getToken(CPP14Parser::Typeid_, 0);
}


size_t CPP14Parser::TypeIdOfTheTypeIdContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeIdOfTheTypeId;
}


std::any CPP14Parser::TypeIdOfTheTypeIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeIdOfTheTypeId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeIdOfTheTypeIdContext* CPP14Parser::typeIdOfTheTypeId() {
  TypeIdOfTheTypeIdContext *_localctx = _tracker.createInstance<TypeIdOfTheTypeIdContext>(_ctx, getState());
  enterRule(_localctx, 32, CPP14Parser::RuleTypeIdOfTheTypeId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(574);
    match(CPP14Parser::Typeid_);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionListContext ------------------------------------------------------------------

CPP14Parser::ExpressionListContext::ExpressionListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::InitializerListContext* CPP14Parser::ExpressionListContext::initializerList() {
  return getRuleContext<CPP14Parser::InitializerListContext>(0);
}


size_t CPP14Parser::ExpressionListContext::getRuleIndex() const {
  return CPP14Parser::RuleExpressionList;
}


std::any CPP14Parser::ExpressionListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExpressionList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExpressionListContext* CPP14Parser::expressionList() {
  ExpressionListContext *_localctx = _tracker.createInstance<ExpressionListContext>(_ctx, getState());
  enterRule(_localctx, 34, CPP14Parser::RuleExpressionList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(576);
    initializerList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PseudoDestructorNameContext ------------------------------------------------------------------

CPP14Parser::PseudoDestructorNameContext::PseudoDestructorNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Tilde() {
  return getToken(CPP14Parser::Tilde, 0);
}

std::vector<CPP14Parser::TheTypeNameContext *> CPP14Parser::PseudoDestructorNameContext::theTypeName() {
  return getRuleContexts<CPP14Parser::TheTypeNameContext>();
}

CPP14Parser::TheTypeNameContext* CPP14Parser::PseudoDestructorNameContext::theTypeName(size_t i) {
  return getRuleContext<CPP14Parser::TheTypeNameContext>(i);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::PseudoDestructorNameContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

tree::TerminalNode* CPP14Parser::PseudoDestructorNameContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::PseudoDestructorNameContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::PseudoDestructorNameContext::decltypeSpecifier() {
  return getRuleContext<CPP14Parser::DecltypeSpecifierContext>(0);
}


size_t CPP14Parser::PseudoDestructorNameContext::getRuleIndex() const {
  return CPP14Parser::RulePseudoDestructorName;
}


std::any CPP14Parser::PseudoDestructorNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPseudoDestructorName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PseudoDestructorNameContext* CPP14Parser::pseudoDestructorName() {
  PseudoDestructorNameContext *_localctx = _tracker.createInstance<PseudoDestructorNameContext>(_ctx, getState());
  enterRule(_localctx, 36, CPP14Parser::RulePseudoDestructorName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(597);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(579);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
      case 1: {
        setState(578);
        nestedNameSpecifier(0);
        break;
      }

      default:
        break;
      }
      setState(584);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Identifier) {
        setState(581);
        theTypeName();
        setState(582);
        match(CPP14Parser::Doublecolon);
      }
      setState(586);
      match(CPP14Parser::Tilde);
      setState(587);
      theTypeName();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(588);
      nestedNameSpecifier(0);
      setState(589);
      match(CPP14Parser::Template);
      setState(590);
      simpleTemplateId();
      setState(591);
      match(CPP14Parser::Doublecolon);
      setState(592);
      match(CPP14Parser::Tilde);
      setState(593);
      theTypeName();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(595);
      match(CPP14Parser::Tilde);
      setState(596);
      decltypeSpecifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnaryExpressionContext ------------------------------------------------------------------

CPP14Parser::UnaryExpressionContext::UnaryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PostfixExpressionContext* CPP14Parser::UnaryExpressionContext::postfixExpression() {
  return getRuleContext<CPP14Parser::PostfixExpressionContext>(0);
}

CPP14Parser::UnaryExpressionContext* CPP14Parser::UnaryExpressionContext::unaryExpression() {
  return getRuleContext<CPP14Parser::UnaryExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::PlusPlus() {
  return getToken(CPP14Parser::PlusPlus, 0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::MinusMinus() {
  return getToken(CPP14Parser::MinusMinus, 0);
}

CPP14Parser::UnaryOperatorContext* CPP14Parser::UnaryExpressionContext::unaryOperator() {
  return getRuleContext<CPP14Parser::UnaryOperatorContext>(0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Sizeof() {
  return getToken(CPP14Parser::Sizeof, 0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::UnaryExpressionContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::UnaryExpressionContext::Alignof() {
  return getToken(CPP14Parser::Alignof, 0);
}

CPP14Parser::NoExceptExpressionContext* CPP14Parser::UnaryExpressionContext::noExceptExpression() {
  return getRuleContext<CPP14Parser::NoExceptExpressionContext>(0);
}

CPP14Parser::NewExpressionContext* CPP14Parser::UnaryExpressionContext::newExpression() {
  return getRuleContext<CPP14Parser::NewExpressionContext>(0);
}

CPP14Parser::DeleteExpressionContext* CPP14Parser::UnaryExpressionContext::deleteExpression() {
  return getRuleContext<CPP14Parser::DeleteExpressionContext>(0);
}


size_t CPP14Parser::UnaryExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleUnaryExpression;
}


std::any CPP14Parser::UnaryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitUnaryExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::UnaryExpressionContext* CPP14Parser::unaryExpression() {
  UnaryExpressionContext *_localctx = _tracker.createInstance<UnaryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 38, CPP14Parser::RuleUnaryExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(626);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 42, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(599);
      postfixExpression(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(604);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::PlusPlus: {
          setState(600);
          match(CPP14Parser::PlusPlus);
          break;
        }

        case CPP14Parser::MinusMinus: {
          setState(601);
          match(CPP14Parser::MinusMinus);
          break;
        }

        case CPP14Parser::Plus:
        case CPP14Parser::Minus:
        case CPP14Parser::Star:
        case CPP14Parser::And:
        case CPP14Parser::Or:
        case CPP14Parser::Tilde:
        case CPP14Parser::Not: {
          setState(602);
          unaryOperator();
          break;
        }

        case CPP14Parser::Sizeof: {
          setState(603);
          match(CPP14Parser::Sizeof);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(606);
      unaryExpression();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(607);
      match(CPP14Parser::Sizeof);
      setState(616);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::LeftParen: {
          setState(608);
          match(CPP14Parser::LeftParen);
          setState(609);
          theTypeId();
          setState(610);
          match(CPP14Parser::RightParen);
          break;
        }

        case CPP14Parser::Ellipsis: {
          setState(612);
          match(CPP14Parser::Ellipsis);
          setState(613);
          match(CPP14Parser::LeftParen);
          setState(614);
          match(CPP14Parser::Identifier);
          setState(615);
          match(CPP14Parser::RightParen);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(618);
      match(CPP14Parser::Alignof);
      setState(619);
      match(CPP14Parser::LeftParen);
      setState(620);
      theTypeId();
      setState(621);
      match(CPP14Parser::RightParen);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(623);
      noExceptExpression();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(624);
      newExpression();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(625);
      deleteExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnaryOperatorContext ------------------------------------------------------------------

CPP14Parser::UnaryOperatorContext::UnaryOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Or() {
  return getToken(CPP14Parser::Or, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Star() {
  return getToken(CPP14Parser::Star, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Plus() {
  return getToken(CPP14Parser::Plus, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Tilde() {
  return getToken(CPP14Parser::Tilde, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Minus() {
  return getToken(CPP14Parser::Minus, 0);
}

tree::TerminalNode* CPP14Parser::UnaryOperatorContext::Not() {
  return getToken(CPP14Parser::Not, 0);
}


size_t CPP14Parser::UnaryOperatorContext::getRuleIndex() const {
  return CPP14Parser::RuleUnaryOperator;
}


std::any CPP14Parser::UnaryOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitUnaryOperator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::UnaryOperatorContext* CPP14Parser::unaryOperator() {
  UnaryOperatorContext *_localctx = _tracker.createInstance<UnaryOperatorContext>(_ctx, getState());
  enterRule(_localctx, 40, CPP14Parser::RuleUnaryOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(628);
    _la = _input->LA(1);
    if (!((((_la - 91) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 91)) & 967) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NewExpressionContext ------------------------------------------------------------------

CPP14Parser::NewExpressionContext::NewExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NewExpressionContext::New() {
  return getToken(CPP14Parser::New, 0);
}

CPP14Parser::NewTypeIdContext* CPP14Parser::NewExpressionContext::newTypeId() {
  return getRuleContext<CPP14Parser::NewTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::NewExpressionContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

CPP14Parser::NewPlacementContext* CPP14Parser::NewExpressionContext::newPlacement() {
  return getRuleContext<CPP14Parser::NewPlacementContext>(0);
}

CPP14Parser::NewInitializerContext* CPP14Parser::NewExpressionContext::newInitializer() {
  return getRuleContext<CPP14Parser::NewInitializerContext>(0);
}

tree::TerminalNode* CPP14Parser::NewExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::NewExpressionContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::NewExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::NewExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleNewExpression;
}


std::any CPP14Parser::NewExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNewExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NewExpressionContext* CPP14Parser::newExpression() {
  NewExpressionContext *_localctx = _tracker.createInstance<NewExpressionContext>(_ctx, getState());
  enterRule(_localctx, 42, CPP14Parser::RuleNewExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(631);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Doublecolon) {
      setState(630);
      match(CPP14Parser::Doublecolon);
    }
    setState(633);
    match(CPP14Parser::New);
    setState(635);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
    case 1: {
      setState(634);
      newPlacement();
      break;
    }

    default:
      break;
    }
    setState(642);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Enum:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Struct:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        setState(637);
        newTypeId();
        break;
      }

      case CPP14Parser::LeftParen: {
        setState(638);
        match(CPP14Parser::LeftParen);
        setState(639);
        theTypeId();
        setState(640);
        match(CPP14Parser::RightParen);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(645);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::LeftParen

    || _la == CPP14Parser::LeftBrace) {
      setState(644);
      newInitializer();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NewPlacementContext ------------------------------------------------------------------

CPP14Parser::NewPlacementContext::NewPlacementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NewPlacementContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ExpressionListContext* CPP14Parser::NewPlacementContext::expressionList() {
  return getRuleContext<CPP14Parser::ExpressionListContext>(0);
}

tree::TerminalNode* CPP14Parser::NewPlacementContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::NewPlacementContext::getRuleIndex() const {
  return CPP14Parser::RuleNewPlacement;
}


std::any CPP14Parser::NewPlacementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNewPlacement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NewPlacementContext* CPP14Parser::newPlacement() {
  NewPlacementContext *_localctx = _tracker.createInstance<NewPlacementContext>(_ctx, getState());
  enterRule(_localctx, 44, CPP14Parser::RuleNewPlacement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(647);
    match(CPP14Parser::LeftParen);
    setState(648);
    expressionList();
    setState(649);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NewTypeIdContext ------------------------------------------------------------------

CPP14Parser::NewTypeIdContext::NewTypeIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::NewTypeIdContext::typeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TypeSpecifierSeqContext>(0);
}

CPP14Parser::NewDeclaratorContext* CPP14Parser::NewTypeIdContext::newDeclarator() {
  return getRuleContext<CPP14Parser::NewDeclaratorContext>(0);
}


size_t CPP14Parser::NewTypeIdContext::getRuleIndex() const {
  return CPP14Parser::RuleNewTypeId;
}


std::any CPP14Parser::NewTypeIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNewTypeId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NewTypeIdContext* CPP14Parser::newTypeId() {
  NewTypeIdContext *_localctx = _tracker.createInstance<NewTypeIdContext>(_ctx, getState());
  enterRule(_localctx, 46, CPP14Parser::RuleNewTypeId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(651);
    typeSpecifierSeq();
    setState(653);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
    case 1: {
      setState(652);
      newDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NewDeclaratorContext ------------------------------------------------------------------

CPP14Parser::NewDeclaratorContext::NewDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PointerOperatorContext* CPP14Parser::NewDeclaratorContext::pointerOperator() {
  return getRuleContext<CPP14Parser::PointerOperatorContext>(0);
}

CPP14Parser::NewDeclaratorContext* CPP14Parser::NewDeclaratorContext::newDeclarator() {
  return getRuleContext<CPP14Parser::NewDeclaratorContext>(0);
}

CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::NewDeclaratorContext::noPointerNewDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerNewDeclaratorContext>(0);
}


size_t CPP14Parser::NewDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleNewDeclarator;
}


std::any CPP14Parser::NewDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNewDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NewDeclaratorContext* CPP14Parser::newDeclarator() {
  NewDeclaratorContext *_localctx = _tracker.createInstance<NewDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 48, CPP14Parser::RuleNewDeclarator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(660);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Decltype:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::AndAnd:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(655);
        pointerOperator();
        setState(657);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
        case 1: {
          setState(656);
          newDeclarator();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 2);
        setState(659);
        noPointerNewDeclarator(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoPointerNewDeclaratorContext ------------------------------------------------------------------

CPP14Parser::NoPointerNewDeclaratorContext::NoPointerNewDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NoPointerNewDeclaratorContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::NoPointerNewDeclaratorContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerNewDeclaratorContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerNewDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::NoPointerNewDeclaratorContext::noPointerNewDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerNewDeclaratorContext>(0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerNewDeclaratorContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}


size_t CPP14Parser::NoPointerNewDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleNoPointerNewDeclarator;
}


std::any CPP14Parser::NoPointerNewDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoPointerNewDeclarator(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::noPointerNewDeclarator() {
   return noPointerNewDeclarator(0);
}

CPP14Parser::NoPointerNewDeclaratorContext* CPP14Parser::noPointerNewDeclarator(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::NoPointerNewDeclaratorContext *_localctx = _tracker.createInstance<NoPointerNewDeclaratorContext>(_ctx, parentState);
  CPP14Parser::NoPointerNewDeclaratorContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 50;
  enterRecursionRule(_localctx, 50, CPP14Parser::RuleNoPointerNewDeclarator, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(663);
    match(CPP14Parser::LeftBracket);
    setState(664);
    expression();
    setState(665);
    match(CPP14Parser::RightBracket);
    setState(667);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 50, _ctx)) {
    case 1: {
      setState(666);
      attributeSpecifierSeq();
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(678);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<NoPointerNewDeclaratorContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleNoPointerNewDeclarator);
        setState(669);

        if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
        setState(670);
        match(CPP14Parser::LeftBracket);
        setState(671);
        constantExpression();
        setState(672);
        match(CPP14Parser::RightBracket);
        setState(674);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx)) {
        case 1: {
          setState(673);
          attributeSpecifierSeq();
          break;
        }

        default:
          break;
        } 
      }
      setState(680);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- NewInitializerContext ------------------------------------------------------------------

CPP14Parser::NewInitializerContext::NewInitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NewInitializerContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::NewInitializerContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::ExpressionListContext* CPP14Parser::NewInitializerContext::expressionList() {
  return getRuleContext<CPP14Parser::ExpressionListContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::NewInitializerContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}


size_t CPP14Parser::NewInitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleNewInitializer;
}


std::any CPP14Parser::NewInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNewInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NewInitializerContext* CPP14Parser::newInitializer() {
  NewInitializerContext *_localctx = _tracker.createInstance<NewInitializerContext>(_ctx, getState());
  enterRule(_localctx, 52, CPP14Parser::RuleNewInitializer);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(687);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftParen: {
        enterOuterAlt(_localctx, 1);
        setState(681);
        match(CPP14Parser::LeftParen);
        setState(683);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 65)) & 4719772474400910417) != 0 || _la == CPP14Parser::Identifier) {
          setState(682);
          expressionList();
        }
        setState(685);
        match(CPP14Parser::RightParen);
        break;
      }

      case CPP14Parser::LeftBrace: {
        enterOuterAlt(_localctx, 2);
        setState(686);
        bracedInitList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeleteExpressionContext ------------------------------------------------------------------

CPP14Parser::DeleteExpressionContext::DeleteExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::DeleteExpressionContext::Delete() {
  return getToken(CPP14Parser::Delete, 0);
}

CPP14Parser::CastExpressionContext* CPP14Parser::DeleteExpressionContext::castExpression() {
  return getRuleContext<CPP14Parser::CastExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::DeleteExpressionContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

tree::TerminalNode* CPP14Parser::DeleteExpressionContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::DeleteExpressionContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}


size_t CPP14Parser::DeleteExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleDeleteExpression;
}


std::any CPP14Parser::DeleteExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeleteExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeleteExpressionContext* CPP14Parser::deleteExpression() {
  DeleteExpressionContext *_localctx = _tracker.createInstance<DeleteExpressionContext>(_ctx, getState());
  enterRule(_localctx, 54, CPP14Parser::RuleDeleteExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(690);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Doublecolon) {
      setState(689);
      match(CPP14Parser::Doublecolon);
    }
    setState(692);
    match(CPP14Parser::Delete);
    setState(695);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
    case 1: {
      setState(693);
      match(CPP14Parser::LeftBracket);
      setState(694);
      match(CPP14Parser::RightBracket);
      break;
    }

    default:
      break;
    }
    setState(697);
    castExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoExceptExpressionContext ------------------------------------------------------------------

CPP14Parser::NoExceptExpressionContext::NoExceptExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::Noexcept() {
  return getToken(CPP14Parser::Noexcept, 0);
}

tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::NoExceptExpressionContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::NoExceptExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::NoExceptExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleNoExceptExpression;
}


std::any CPP14Parser::NoExceptExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoExceptExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NoExceptExpressionContext* CPP14Parser::noExceptExpression() {
  NoExceptExpressionContext *_localctx = _tracker.createInstance<NoExceptExpressionContext>(_ctx, getState());
  enterRule(_localctx, 56, CPP14Parser::RuleNoExceptExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(699);
    match(CPP14Parser::Noexcept);
    setState(700);
    match(CPP14Parser::LeftParen);
    setState(701);
    expression();
    setState(702);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CastExpressionContext ------------------------------------------------------------------

CPP14Parser::CastExpressionContext::CastExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::UnaryExpressionContext* CPP14Parser::CastExpressionContext::unaryExpression() {
  return getRuleContext<CPP14Parser::UnaryExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::CastExpressionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::CastExpressionContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::CastExpressionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::CastExpressionContext* CPP14Parser::CastExpressionContext::castExpression() {
  return getRuleContext<CPP14Parser::CastExpressionContext>(0);
}


size_t CPP14Parser::CastExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleCastExpression;
}


std::any CPP14Parser::CastExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCastExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CastExpressionContext* CPP14Parser::castExpression() {
  CastExpressionContext *_localctx = _tracker.createInstance<CastExpressionContext>(_ctx, getState());
  enterRule(_localctx, 58, CPP14Parser::RuleCastExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(710);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(704);
      unaryExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(705);
      match(CPP14Parser::LeftParen);
      setState(706);
      theTypeId();
      setState(707);
      match(CPP14Parser::RightParen);
      setState(708);
      castExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PointerMemberExpressionContext ------------------------------------------------------------------

CPP14Parser::PointerMemberExpressionContext::PointerMemberExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::CastExpressionContext *> CPP14Parser::PointerMemberExpressionContext::castExpression() {
  return getRuleContexts<CPP14Parser::CastExpressionContext>();
}

CPP14Parser::CastExpressionContext* CPP14Parser::PointerMemberExpressionContext::castExpression(size_t i) {
  return getRuleContext<CPP14Parser::CastExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::PointerMemberExpressionContext::DotStar() {
  return getTokens(CPP14Parser::DotStar);
}

tree::TerminalNode* CPP14Parser::PointerMemberExpressionContext::DotStar(size_t i) {
  return getToken(CPP14Parser::DotStar, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::PointerMemberExpressionContext::ArrowStar() {
  return getTokens(CPP14Parser::ArrowStar);
}

tree::TerminalNode* CPP14Parser::PointerMemberExpressionContext::ArrowStar(size_t i) {
  return getToken(CPP14Parser::ArrowStar, i);
}


size_t CPP14Parser::PointerMemberExpressionContext::getRuleIndex() const {
  return CPP14Parser::RulePointerMemberExpression;
}


std::any CPP14Parser::PointerMemberExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPointerMemberExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PointerMemberExpressionContext* CPP14Parser::pointerMemberExpression() {
  PointerMemberExpressionContext *_localctx = _tracker.createInstance<PointerMemberExpressionContext>(_ctx, getState());
  enterRule(_localctx, 60, CPP14Parser::RulePointerMemberExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(712);
    castExpression();
    setState(717);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::ArrowStar

    || _la == CPP14Parser::DotStar) {
      setState(713);
      _la = _input->LA(1);
      if (!(_la == CPP14Parser::ArrowStar

      || _la == CPP14Parser::DotStar)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(714);
      castExpression();
      setState(719);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MultiplicativeExpressionContext ------------------------------------------------------------------

CPP14Parser::MultiplicativeExpressionContext::MultiplicativeExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::PointerMemberExpressionContext *> CPP14Parser::MultiplicativeExpressionContext::pointerMemberExpression() {
  return getRuleContexts<CPP14Parser::PointerMemberExpressionContext>();
}

CPP14Parser::PointerMemberExpressionContext* CPP14Parser::MultiplicativeExpressionContext::pointerMemberExpression(size_t i) {
  return getRuleContext<CPP14Parser::PointerMemberExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MultiplicativeExpressionContext::Star() {
  return getTokens(CPP14Parser::Star);
}

tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Star(size_t i) {
  return getToken(CPP14Parser::Star, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MultiplicativeExpressionContext::Div() {
  return getTokens(CPP14Parser::Div);
}

tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Div(size_t i) {
  return getToken(CPP14Parser::Div, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MultiplicativeExpressionContext::Mod() {
  return getTokens(CPP14Parser::Mod);
}

tree::TerminalNode* CPP14Parser::MultiplicativeExpressionContext::Mod(size_t i) {
  return getToken(CPP14Parser::Mod, i);
}


size_t CPP14Parser::MultiplicativeExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleMultiplicativeExpression;
}


std::any CPP14Parser::MultiplicativeExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMultiplicativeExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MultiplicativeExpressionContext* CPP14Parser::multiplicativeExpression() {
  MultiplicativeExpressionContext *_localctx = _tracker.createInstance<MultiplicativeExpressionContext>(_ctx, getState());
  enterRule(_localctx, 62, CPP14Parser::RuleMultiplicativeExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(720);
    pointerMemberExpression();
    setState(725);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la - 93) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 93)) & 7) != 0) {
      setState(721);
      _la = _input->LA(1);
      if (!((((_la - 93) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 93)) & 7) != 0)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(722);
      pointerMemberExpression();
      setState(727);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AdditiveExpressionContext ------------------------------------------------------------------

CPP14Parser::AdditiveExpressionContext::AdditiveExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::MultiplicativeExpressionContext *> CPP14Parser::AdditiveExpressionContext::multiplicativeExpression() {
  return getRuleContexts<CPP14Parser::MultiplicativeExpressionContext>();
}

CPP14Parser::MultiplicativeExpressionContext* CPP14Parser::AdditiveExpressionContext::multiplicativeExpression(size_t i) {
  return getRuleContext<CPP14Parser::MultiplicativeExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::AdditiveExpressionContext::Plus() {
  return getTokens(CPP14Parser::Plus);
}

tree::TerminalNode* CPP14Parser::AdditiveExpressionContext::Plus(size_t i) {
  return getToken(CPP14Parser::Plus, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::AdditiveExpressionContext::Minus() {
  return getTokens(CPP14Parser::Minus);
}

tree::TerminalNode* CPP14Parser::AdditiveExpressionContext::Minus(size_t i) {
  return getToken(CPP14Parser::Minus, i);
}


size_t CPP14Parser::AdditiveExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleAdditiveExpression;
}


std::any CPP14Parser::AdditiveExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAdditiveExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AdditiveExpressionContext* CPP14Parser::additiveExpression() {
  AdditiveExpressionContext *_localctx = _tracker.createInstance<AdditiveExpressionContext>(_ctx, getState());
  enterRule(_localctx, 64, CPP14Parser::RuleAdditiveExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(728);
    multiplicativeExpression();
    setState(733);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Plus

    || _la == CPP14Parser::Minus) {
      setState(729);
      _la = _input->LA(1);
      if (!(_la == CPP14Parser::Plus

      || _la == CPP14Parser::Minus)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(730);
      multiplicativeExpression();
      setState(735);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShiftExpressionContext ------------------------------------------------------------------

CPP14Parser::ShiftExpressionContext::ShiftExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::AdditiveExpressionContext *> CPP14Parser::ShiftExpressionContext::additiveExpression() {
  return getRuleContexts<CPP14Parser::AdditiveExpressionContext>();
}

CPP14Parser::AdditiveExpressionContext* CPP14Parser::ShiftExpressionContext::additiveExpression(size_t i) {
  return getRuleContext<CPP14Parser::AdditiveExpressionContext>(i);
}

std::vector<CPP14Parser::ShiftOperatorContext *> CPP14Parser::ShiftExpressionContext::shiftOperator() {
  return getRuleContexts<CPP14Parser::ShiftOperatorContext>();
}

CPP14Parser::ShiftOperatorContext* CPP14Parser::ShiftExpressionContext::shiftOperator(size_t i) {
  return getRuleContext<CPP14Parser::ShiftOperatorContext>(i);
}


size_t CPP14Parser::ShiftExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleShiftExpression;
}


std::any CPP14Parser::ShiftExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitShiftExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ShiftExpressionContext* CPP14Parser::shiftExpression() {
  ShiftExpressionContext *_localctx = _tracker.createInstance<ShiftExpressionContext>(_ctx, getState());
  enterRule(_localctx, 66, CPP14Parser::RuleShiftExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(736);
    additiveExpression();
    setState(742);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(737);
        shiftOperator();
        setState(738);
        additiveExpression(); 
      }
      setState(744);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShiftOperatorContext ------------------------------------------------------------------

CPP14Parser::ShiftOperatorContext::ShiftOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CPP14Parser::ShiftOperatorContext::Greater() {
  return getTokens(CPP14Parser::Greater);
}

tree::TerminalNode* CPP14Parser::ShiftOperatorContext::Greater(size_t i) {
  return getToken(CPP14Parser::Greater, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::ShiftOperatorContext::Less() {
  return getTokens(CPP14Parser::Less);
}

tree::TerminalNode* CPP14Parser::ShiftOperatorContext::Less(size_t i) {
  return getToken(CPP14Parser::Less, i);
}


size_t CPP14Parser::ShiftOperatorContext::getRuleIndex() const {
  return CPP14Parser::RuleShiftOperator;
}


std::any CPP14Parser::ShiftOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitShiftOperator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ShiftOperatorContext* CPP14Parser::shiftOperator() {
  ShiftOperatorContext *_localctx = _tracker.createInstance<ShiftOperatorContext>(_ctx, getState());
  enterRule(_localctx, 68, CPP14Parser::RuleShiftOperator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(749);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Greater: {
        enterOuterAlt(_localctx, 1);
        setState(745);
        match(CPP14Parser::Greater);
        setState(746);
        match(CPP14Parser::Greater);
        break;
      }

      case CPP14Parser::Less: {
        enterOuterAlt(_localctx, 2);
        setState(747);
        match(CPP14Parser::Less);
        setState(748);
        match(CPP14Parser::Less);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RelationalExpressionContext ------------------------------------------------------------------

CPP14Parser::RelationalExpressionContext::RelationalExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::ShiftExpressionContext *> CPP14Parser::RelationalExpressionContext::shiftExpression() {
  return getRuleContexts<CPP14Parser::ShiftExpressionContext>();
}

CPP14Parser::ShiftExpressionContext* CPP14Parser::RelationalExpressionContext::shiftExpression(size_t i) {
  return getRuleContext<CPP14Parser::ShiftExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::RelationalExpressionContext::Less() {
  return getTokens(CPP14Parser::Less);
}

tree::TerminalNode* CPP14Parser::RelationalExpressionContext::Less(size_t i) {
  return getToken(CPP14Parser::Less, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::RelationalExpressionContext::Greater() {
  return getTokens(CPP14Parser::Greater);
}

tree::TerminalNode* CPP14Parser::RelationalExpressionContext::Greater(size_t i) {
  return getToken(CPP14Parser::Greater, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::RelationalExpressionContext::LessEqual() {
  return getTokens(CPP14Parser::LessEqual);
}

tree::TerminalNode* CPP14Parser::RelationalExpressionContext::LessEqual(size_t i) {
  return getToken(CPP14Parser::LessEqual, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::RelationalExpressionContext::GreaterEqual() {
  return getTokens(CPP14Parser::GreaterEqual);
}

tree::TerminalNode* CPP14Parser::RelationalExpressionContext::GreaterEqual(size_t i) {
  return getToken(CPP14Parser::GreaterEqual, i);
}


size_t CPP14Parser::RelationalExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleRelationalExpression;
}


std::any CPP14Parser::RelationalExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitRelationalExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::RelationalExpressionContext* CPP14Parser::relationalExpression() {
  RelationalExpressionContext *_localctx = _tracker.createInstance<RelationalExpressionContext>(_ctx, getState());
  enterRule(_localctx, 70, CPP14Parser::RuleRelationalExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(751);
    shiftExpression();
    setState(756);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(752);
        _la = _input->LA(1);
        if (!((((_la - 102) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 102)) & 49155) != 0)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(753);
        shiftExpression(); 
      }
      setState(758);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EqualityExpressionContext ------------------------------------------------------------------

CPP14Parser::EqualityExpressionContext::EqualityExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::RelationalExpressionContext *> CPP14Parser::EqualityExpressionContext::relationalExpression() {
  return getRuleContexts<CPP14Parser::RelationalExpressionContext>();
}

CPP14Parser::RelationalExpressionContext* CPP14Parser::EqualityExpressionContext::relationalExpression(size_t i) {
  return getRuleContext<CPP14Parser::RelationalExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::EqualityExpressionContext::Equal() {
  return getTokens(CPP14Parser::Equal);
}

tree::TerminalNode* CPP14Parser::EqualityExpressionContext::Equal(size_t i) {
  return getToken(CPP14Parser::Equal, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::EqualityExpressionContext::NotEqual() {
  return getTokens(CPP14Parser::NotEqual);
}

tree::TerminalNode* CPP14Parser::EqualityExpressionContext::NotEqual(size_t i) {
  return getToken(CPP14Parser::NotEqual, i);
}


size_t CPP14Parser::EqualityExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleEqualityExpression;
}


std::any CPP14Parser::EqualityExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEqualityExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EqualityExpressionContext* CPP14Parser::equalityExpression() {
  EqualityExpressionContext *_localctx = _tracker.createInstance<EqualityExpressionContext>(_ctx, getState());
  enterRule(_localctx, 72, CPP14Parser::RuleEqualityExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(759);
    relationalExpression();
    setState(764);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Equal

    || _la == CPP14Parser::NotEqual) {
      setState(760);
      _la = _input->LA(1);
      if (!(_la == CPP14Parser::Equal

      || _la == CPP14Parser::NotEqual)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(761);
      relationalExpression();
      setState(766);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AndExpressionContext ------------------------------------------------------------------

CPP14Parser::AndExpressionContext::AndExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::EqualityExpressionContext *> CPP14Parser::AndExpressionContext::equalityExpression() {
  return getRuleContexts<CPP14Parser::EqualityExpressionContext>();
}

CPP14Parser::EqualityExpressionContext* CPP14Parser::AndExpressionContext::equalityExpression(size_t i) {
  return getRuleContext<CPP14Parser::EqualityExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::AndExpressionContext::And() {
  return getTokens(CPP14Parser::And);
}

tree::TerminalNode* CPP14Parser::AndExpressionContext::And(size_t i) {
  return getToken(CPP14Parser::And, i);
}


size_t CPP14Parser::AndExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleAndExpression;
}


std::any CPP14Parser::AndExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAndExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AndExpressionContext* CPP14Parser::andExpression() {
  AndExpressionContext *_localctx = _tracker.createInstance<AndExpressionContext>(_ctx, getState());
  enterRule(_localctx, 74, CPP14Parser::RuleAndExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(767);
    equalityExpression();
    setState(772);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::And) {
      setState(768);
      match(CPP14Parser::And);
      setState(769);
      equalityExpression();
      setState(774);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExclusiveOrExpressionContext ------------------------------------------------------------------

CPP14Parser::ExclusiveOrExpressionContext::ExclusiveOrExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::AndExpressionContext *> CPP14Parser::ExclusiveOrExpressionContext::andExpression() {
  return getRuleContexts<CPP14Parser::AndExpressionContext>();
}

CPP14Parser::AndExpressionContext* CPP14Parser::ExclusiveOrExpressionContext::andExpression(size_t i) {
  return getRuleContext<CPP14Parser::AndExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::ExclusiveOrExpressionContext::Caret() {
  return getTokens(CPP14Parser::Caret);
}

tree::TerminalNode* CPP14Parser::ExclusiveOrExpressionContext::Caret(size_t i) {
  return getToken(CPP14Parser::Caret, i);
}


size_t CPP14Parser::ExclusiveOrExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleExclusiveOrExpression;
}


std::any CPP14Parser::ExclusiveOrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExclusiveOrExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExclusiveOrExpressionContext* CPP14Parser::exclusiveOrExpression() {
  ExclusiveOrExpressionContext *_localctx = _tracker.createInstance<ExclusiveOrExpressionContext>(_ctx, getState());
  enterRule(_localctx, 76, CPP14Parser::RuleExclusiveOrExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(775);
    andExpression();
    setState(780);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Caret) {
      setState(776);
      match(CPP14Parser::Caret);
      setState(777);
      andExpression();
      setState(782);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InclusiveOrExpressionContext ------------------------------------------------------------------

CPP14Parser::InclusiveOrExpressionContext::InclusiveOrExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::ExclusiveOrExpressionContext *> CPP14Parser::InclusiveOrExpressionContext::exclusiveOrExpression() {
  return getRuleContexts<CPP14Parser::ExclusiveOrExpressionContext>();
}

CPP14Parser::ExclusiveOrExpressionContext* CPP14Parser::InclusiveOrExpressionContext::exclusiveOrExpression(size_t i) {
  return getRuleContext<CPP14Parser::ExclusiveOrExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::InclusiveOrExpressionContext::Or() {
  return getTokens(CPP14Parser::Or);
}

tree::TerminalNode* CPP14Parser::InclusiveOrExpressionContext::Or(size_t i) {
  return getToken(CPP14Parser::Or, i);
}


size_t CPP14Parser::InclusiveOrExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleInclusiveOrExpression;
}


std::any CPP14Parser::InclusiveOrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInclusiveOrExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InclusiveOrExpressionContext* CPP14Parser::inclusiveOrExpression() {
  InclusiveOrExpressionContext *_localctx = _tracker.createInstance<InclusiveOrExpressionContext>(_ctx, getState());
  enterRule(_localctx, 78, CPP14Parser::RuleInclusiveOrExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(783);
    exclusiveOrExpression();
    setState(788);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Or) {
      setState(784);
      match(CPP14Parser::Or);
      setState(785);
      exclusiveOrExpression();
      setState(790);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogicalAndExpressionContext ------------------------------------------------------------------

CPP14Parser::LogicalAndExpressionContext::LogicalAndExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::InclusiveOrExpressionContext *> CPP14Parser::LogicalAndExpressionContext::inclusiveOrExpression() {
  return getRuleContexts<CPP14Parser::InclusiveOrExpressionContext>();
}

CPP14Parser::InclusiveOrExpressionContext* CPP14Parser::LogicalAndExpressionContext::inclusiveOrExpression(size_t i) {
  return getRuleContext<CPP14Parser::InclusiveOrExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::LogicalAndExpressionContext::AndAnd() {
  return getTokens(CPP14Parser::AndAnd);
}

tree::TerminalNode* CPP14Parser::LogicalAndExpressionContext::AndAnd(size_t i) {
  return getToken(CPP14Parser::AndAnd, i);
}


size_t CPP14Parser::LogicalAndExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleLogicalAndExpression;
}


std::any CPP14Parser::LogicalAndExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLogicalAndExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LogicalAndExpressionContext* CPP14Parser::logicalAndExpression() {
  LogicalAndExpressionContext *_localctx = _tracker.createInstance<LogicalAndExpressionContext>(_ctx, getState());
  enterRule(_localctx, 80, CPP14Parser::RuleLogicalAndExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(791);
    inclusiveOrExpression();
    setState(796);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::AndAnd) {
      setState(792);
      match(CPP14Parser::AndAnd);
      setState(793);
      inclusiveOrExpression();
      setState(798);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogicalOrExpressionContext ------------------------------------------------------------------

CPP14Parser::LogicalOrExpressionContext::LogicalOrExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::LogicalAndExpressionContext *> CPP14Parser::LogicalOrExpressionContext::logicalAndExpression() {
  return getRuleContexts<CPP14Parser::LogicalAndExpressionContext>();
}

CPP14Parser::LogicalAndExpressionContext* CPP14Parser::LogicalOrExpressionContext::logicalAndExpression(size_t i) {
  return getRuleContext<CPP14Parser::LogicalAndExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::LogicalOrExpressionContext::OrOr() {
  return getTokens(CPP14Parser::OrOr);
}

tree::TerminalNode* CPP14Parser::LogicalOrExpressionContext::OrOr(size_t i) {
  return getToken(CPP14Parser::OrOr, i);
}


size_t CPP14Parser::LogicalOrExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleLogicalOrExpression;
}


std::any CPP14Parser::LogicalOrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLogicalOrExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LogicalOrExpressionContext* CPP14Parser::logicalOrExpression() {
  LogicalOrExpressionContext *_localctx = _tracker.createInstance<LogicalOrExpressionContext>(_ctx, getState());
  enterRule(_localctx, 82, CPP14Parser::RuleLogicalOrExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(799);
    logicalAndExpression();
    setState(804);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::OrOr) {
      setState(800);
      match(CPP14Parser::OrOr);
      setState(801);
      logicalAndExpression();
      setState(806);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConditionalExpressionContext ------------------------------------------------------------------

CPP14Parser::ConditionalExpressionContext::ConditionalExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::LogicalOrExpressionContext* CPP14Parser::ConditionalExpressionContext::logicalOrExpression() {
  return getRuleContext<CPP14Parser::LogicalOrExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::ConditionalExpressionContext::Question() {
  return getToken(CPP14Parser::Question, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::ConditionalExpressionContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::ConditionalExpressionContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::AssignmentExpressionContext* CPP14Parser::ConditionalExpressionContext::assignmentExpression() {
  return getRuleContext<CPP14Parser::AssignmentExpressionContext>(0);
}


size_t CPP14Parser::ConditionalExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleConditionalExpression;
}


std::any CPP14Parser::ConditionalExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConditionalExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConditionalExpressionContext* CPP14Parser::conditionalExpression() {
  ConditionalExpressionContext *_localctx = _tracker.createInstance<ConditionalExpressionContext>(_ctx, getState());
  enterRule(_localctx, 84, CPP14Parser::RuleConditionalExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(807);
    logicalOrExpression();
    setState(813);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Question) {
      setState(808);
      match(CPP14Parser::Question);
      setState(809);
      expression();
      setState(810);
      match(CPP14Parser::Colon);
      setState(811);
      assignmentExpression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentExpressionContext ------------------------------------------------------------------

CPP14Parser::AssignmentExpressionContext::AssignmentExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ConditionalExpressionContext* CPP14Parser::AssignmentExpressionContext::conditionalExpression() {
  return getRuleContext<CPP14Parser::ConditionalExpressionContext>(0);
}

CPP14Parser::LogicalOrExpressionContext* CPP14Parser::AssignmentExpressionContext::logicalOrExpression() {
  return getRuleContext<CPP14Parser::LogicalOrExpressionContext>(0);
}

CPP14Parser::AssignmentOperatorContext* CPP14Parser::AssignmentExpressionContext::assignmentOperator() {
  return getRuleContext<CPP14Parser::AssignmentOperatorContext>(0);
}

CPP14Parser::InitializerClauseContext* CPP14Parser::AssignmentExpressionContext::initializerClause() {
  return getRuleContext<CPP14Parser::InitializerClauseContext>(0);
}

CPP14Parser::ThrowExpressionContext* CPP14Parser::AssignmentExpressionContext::throwExpression() {
  return getRuleContext<CPP14Parser::ThrowExpressionContext>(0);
}


size_t CPP14Parser::AssignmentExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleAssignmentExpression;
}


std::any CPP14Parser::AssignmentExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAssignmentExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AssignmentExpressionContext* CPP14Parser::assignmentExpression() {
  AssignmentExpressionContext *_localctx = _tracker.createInstance<AssignmentExpressionContext>(_ctx, getState());
  enterRule(_localctx, 86, CPP14Parser::RuleAssignmentExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(821);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 71, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(815);
      conditionalExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(816);
      logicalOrExpression();
      setState(817);
      assignmentOperator();
      setState(818);
      initializerClause();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(820);
      throwExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignmentOperatorContext ------------------------------------------------------------------

CPP14Parser::AssignmentOperatorContext::AssignmentOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::StarAssign() {
  return getToken(CPP14Parser::StarAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::DivAssign() {
  return getToken(CPP14Parser::DivAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::ModAssign() {
  return getToken(CPP14Parser::ModAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::PlusAssign() {
  return getToken(CPP14Parser::PlusAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::MinusAssign() {
  return getToken(CPP14Parser::MinusAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::RightShiftAssign() {
  return getToken(CPP14Parser::RightShiftAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::LeftShiftAssign() {
  return getToken(CPP14Parser::LeftShiftAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::AndAssign() {
  return getToken(CPP14Parser::AndAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::XorAssign() {
  return getToken(CPP14Parser::XorAssign, 0);
}

tree::TerminalNode* CPP14Parser::AssignmentOperatorContext::OrAssign() {
  return getToken(CPP14Parser::OrAssign, 0);
}


size_t CPP14Parser::AssignmentOperatorContext::getRuleIndex() const {
  return CPP14Parser::RuleAssignmentOperator;
}


std::any CPP14Parser::AssignmentOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAssignmentOperator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AssignmentOperatorContext* CPP14Parser::assignmentOperator() {
  AssignmentOperatorContext *_localctx = _tracker.createInstance<AssignmentOperatorContext>(_ctx, getState());
  enterRule(_localctx, 88, CPP14Parser::RuleAssignmentOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(823);
    _la = _input->LA(1);
    if (!((((_la - 101) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 101)) & 8185) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionContext ------------------------------------------------------------------

CPP14Parser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::AssignmentExpressionContext *> CPP14Parser::ExpressionContext::assignmentExpression() {
  return getRuleContexts<CPP14Parser::AssignmentExpressionContext>();
}

CPP14Parser::AssignmentExpressionContext* CPP14Parser::ExpressionContext::assignmentExpression(size_t i) {
  return getRuleContext<CPP14Parser::AssignmentExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::ExpressionContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::ExpressionContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::ExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleExpression;
}


std::any CPP14Parser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExpressionContext* CPP14Parser::expression() {
  ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
  enterRule(_localctx, 90, CPP14Parser::RuleExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(825);
    assignmentExpression();
    setState(830);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(826);
      match(CPP14Parser::Comma);
      setState(827);
      assignmentExpression();
      setState(832);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstantExpressionContext ------------------------------------------------------------------

CPP14Parser::ConstantExpressionContext::ConstantExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ConditionalExpressionContext* CPP14Parser::ConstantExpressionContext::conditionalExpression() {
  return getRuleContext<CPP14Parser::ConditionalExpressionContext>(0);
}


size_t CPP14Parser::ConstantExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleConstantExpression;
}


std::any CPP14Parser::ConstantExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConstantExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::constantExpression() {
  ConstantExpressionContext *_localctx = _tracker.createInstance<ConstantExpressionContext>(_ctx, getState());
  enterRule(_localctx, 92, CPP14Parser::RuleConstantExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(833);
    conditionalExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementContext ------------------------------------------------------------------

CPP14Parser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::LabeledStatementContext* CPP14Parser::StatementContext::labeledStatement() {
  return getRuleContext<CPP14Parser::LabeledStatementContext>(0);
}

CPP14Parser::DeclarationStatementContext* CPP14Parser::StatementContext::declarationStatement() {
  return getRuleContext<CPP14Parser::DeclarationStatementContext>(0);
}

CPP14Parser::ExpressionStatementContext* CPP14Parser::StatementContext::expressionStatement() {
  return getRuleContext<CPP14Parser::ExpressionStatementContext>(0);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::StatementContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}

CPP14Parser::SelectionStatementContext* CPP14Parser::StatementContext::selectionStatement() {
  return getRuleContext<CPP14Parser::SelectionStatementContext>(0);
}

CPP14Parser::IterationStatementContext* CPP14Parser::StatementContext::iterationStatement() {
  return getRuleContext<CPP14Parser::IterationStatementContext>(0);
}

CPP14Parser::JumpStatementContext* CPP14Parser::StatementContext::jumpStatement() {
  return getRuleContext<CPP14Parser::JumpStatementContext>(0);
}

CPP14Parser::TryBlockContext* CPP14Parser::StatementContext::tryBlock() {
  return getRuleContext<CPP14Parser::TryBlockContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::StatementContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::StatementContext::getRuleIndex() const {
  return CPP14Parser::RuleStatement;
}


std::any CPP14Parser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::StatementContext* CPP14Parser::statement() {
  StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
  enterRule(_localctx, 94, CPP14Parser::RuleStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(848);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(835);
      labeledStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(836);
      declarationStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(838);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
      case 1: {
        setState(837);
        attributeSpecifierSeq();
        break;
      }

      default:
        break;
      }
      setState(846);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::IntegerLiteral:
        case CPP14Parser::CharacterLiteral:
        case CPP14Parser::FloatingLiteral:
        case CPP14Parser::StringLiteral:
        case CPP14Parser::BooleanLiteral:
        case CPP14Parser::PointerLiteral:
        case CPP14Parser::UserDefinedLiteral:
        case CPP14Parser::Alignof:
        case CPP14Parser::Auto:
        case CPP14Parser::Bool:
        case CPP14Parser::Char:
        case CPP14Parser::Char16:
        case CPP14Parser::Char32:
        case CPP14Parser::Const_cast:
        case CPP14Parser::Decltype:
        case CPP14Parser::Delete:
        case CPP14Parser::Double:
        case CPP14Parser::Dynamic_cast:
        case CPP14Parser::Float:
        case CPP14Parser::Int:
        case CPP14Parser::Long:
        case CPP14Parser::New:
        case CPP14Parser::Noexcept:
        case CPP14Parser::Operator:
        case CPP14Parser::Reinterpret_cast:
        case CPP14Parser::Short:
        case CPP14Parser::Signed:
        case CPP14Parser::Sizeof:
        case CPP14Parser::Static_cast:
        case CPP14Parser::This:
        case CPP14Parser::Throw:
        case CPP14Parser::Typeid_:
        case CPP14Parser::Typename_:
        case CPP14Parser::Unsigned:
        case CPP14Parser::Void:
        case CPP14Parser::Wchar:
        case CPP14Parser::LeftParen:
        case CPP14Parser::LeftBracket:
        case CPP14Parser::Plus:
        case CPP14Parser::Minus:
        case CPP14Parser::Star:
        case CPP14Parser::And:
        case CPP14Parser::Or:
        case CPP14Parser::Tilde:
        case CPP14Parser::Not:
        case CPP14Parser::PlusPlus:
        case CPP14Parser::MinusMinus:
        case CPP14Parser::Doublecolon:
        case CPP14Parser::Semi:
        case CPP14Parser::Identifier: {
          setState(840);
          expressionStatement();
          break;
        }

        case CPP14Parser::LeftBrace: {
          setState(841);
          compoundStatement();
          break;
        }

        case CPP14Parser::If:
        case CPP14Parser::Switch: {
          setState(842);
          selectionStatement();
          break;
        }

        case CPP14Parser::Do:
        case CPP14Parser::For:
        case CPP14Parser::While: {
          setState(843);
          iterationStatement();
          break;
        }

        case CPP14Parser::Break:
        case CPP14Parser::Continue:
        case CPP14Parser::Goto:
        case CPP14Parser::Return: {
          setState(844);
          jumpStatement();
          break;
        }

        case CPP14Parser::Try: {
          setState(845);
          tryBlock();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledStatementContext ------------------------------------------------------------------

CPP14Parser::LabeledStatementContext::LabeledStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LabeledStatementContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::StatementContext* CPP14Parser::LabeledStatementContext::statement() {
  return getRuleContext<CPP14Parser::StatementContext>(0);
}

tree::TerminalNode* CPP14Parser::LabeledStatementContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::LabeledStatementContext::Case() {
  return getToken(CPP14Parser::Case, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::LabeledStatementContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::LabeledStatementContext::Default() {
  return getToken(CPP14Parser::Default, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::LabeledStatementContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::LabeledStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleLabeledStatement;
}


std::any CPP14Parser::LabeledStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLabeledStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LabeledStatementContext* CPP14Parser::labeledStatement() {
  LabeledStatementContext *_localctx = _tracker.createInstance<LabeledStatementContext>(_ctx, getState());
  enterRule(_localctx, 96, CPP14Parser::RuleLabeledStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(851);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(850);
      attributeSpecifierSeq();
    }
    setState(857);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Identifier: {
        setState(853);
        match(CPP14Parser::Identifier);
        break;
      }

      case CPP14Parser::Case: {
        setState(854);
        match(CPP14Parser::Case);
        setState(855);
        constantExpression();
        break;
      }

      case CPP14Parser::Default: {
        setState(856);
        match(CPP14Parser::Default);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(859);
    match(CPP14Parser::Colon);
    setState(860);
    statement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionStatementContext ------------------------------------------------------------------

CPP14Parser::ExpressionStatementContext::ExpressionStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ExpressionStatementContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::ExpressionStatementContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}


size_t CPP14Parser::ExpressionStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleExpressionStatement;
}


std::any CPP14Parser::ExpressionStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExpressionStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExpressionStatementContext* CPP14Parser::expressionStatement() {
  ExpressionStatementContext *_localctx = _tracker.createInstance<ExpressionStatementContext>(_ctx, getState());
  enterRule(_localctx, 98, CPP14Parser::RuleExpressionStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(863);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & 4719772474384133201) != 0 || _la == CPP14Parser::Identifier) {
      setState(862);
      expression();
    }
    setState(865);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CompoundStatementContext ------------------------------------------------------------------

CPP14Parser::CompoundStatementContext::CompoundStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::CompoundStatementContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::CompoundStatementContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

CPP14Parser::StatementSeqContext* CPP14Parser::CompoundStatementContext::statementSeq() {
  return getRuleContext<CPP14Parser::StatementSeqContext>(0);
}


size_t CPP14Parser::CompoundStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleCompoundStatement;
}


std::any CPP14Parser::CompoundStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCompoundStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::compoundStatement() {
  CompoundStatementContext *_localctx = _tracker.createInstance<CompoundStatementContext>(_ctx, getState());
  enterRule(_localctx, 100, CPP14Parser::RuleCompoundStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(867);
    match(CPP14Parser::LeftBrace);
    setState(869);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -137360239606498050) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -8989184726396829969) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 25) != 0) {
      setState(868);
      statementSeq();
    }
    setState(871);
    match(CPP14Parser::RightBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementSeqContext ------------------------------------------------------------------

CPP14Parser::StatementSeqContext::StatementSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::StatementContext *> CPP14Parser::StatementSeqContext::statement() {
  return getRuleContexts<CPP14Parser::StatementContext>();
}

CPP14Parser::StatementContext* CPP14Parser::StatementSeqContext::statement(size_t i) {
  return getRuleContext<CPP14Parser::StatementContext>(i);
}


size_t CPP14Parser::StatementSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleStatementSeq;
}


std::any CPP14Parser::StatementSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitStatementSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::StatementSeqContext* CPP14Parser::statementSeq() {
  StatementSeqContext *_localctx = _tracker.createInstance<StatementSeqContext>(_ctx, getState());
  enterRule(_localctx, 102, CPP14Parser::RuleStatementSeq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(874); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(873);
      statement();
      setState(876); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -137360239606498050) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -8989184726396829969) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 25) != 0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectionStatementContext ------------------------------------------------------------------

CPP14Parser::SelectionStatementContext::SelectionStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::SelectionStatementContext::If() {
  return getToken(CPP14Parser::If, 0);
}

tree::TerminalNode* CPP14Parser::SelectionStatementContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ConditionContext* CPP14Parser::SelectionStatementContext::condition() {
  return getRuleContext<CPP14Parser::ConditionContext>(0);
}

tree::TerminalNode* CPP14Parser::SelectionStatementContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

std::vector<CPP14Parser::StatementContext *> CPP14Parser::SelectionStatementContext::statement() {
  return getRuleContexts<CPP14Parser::StatementContext>();
}

CPP14Parser::StatementContext* CPP14Parser::SelectionStatementContext::statement(size_t i) {
  return getRuleContext<CPP14Parser::StatementContext>(i);
}

tree::TerminalNode* CPP14Parser::SelectionStatementContext::Else() {
  return getToken(CPP14Parser::Else, 0);
}

tree::TerminalNode* CPP14Parser::SelectionStatementContext::Switch() {
  return getToken(CPP14Parser::Switch, 0);
}


size_t CPP14Parser::SelectionStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleSelectionStatement;
}


std::any CPP14Parser::SelectionStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSelectionStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SelectionStatementContext* CPP14Parser::selectionStatement() {
  SelectionStatementContext *_localctx = _tracker.createInstance<SelectionStatementContext>(_ctx, getState());
  enterRule(_localctx, 104, CPP14Parser::RuleSelectionStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(893);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::If: {
        enterOuterAlt(_localctx, 1);
        setState(878);
        match(CPP14Parser::If);
        setState(879);
        match(CPP14Parser::LeftParen);
        setState(880);
        condition();
        setState(881);
        match(CPP14Parser::RightParen);
        setState(882);
        statement();
        setState(885);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx)) {
        case 1: {
          setState(883);
          match(CPP14Parser::Else);
          setState(884);
          statement();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::Switch: {
        enterOuterAlt(_localctx, 2);
        setState(887);
        match(CPP14Parser::Switch);
        setState(888);
        match(CPP14Parser::LeftParen);
        setState(889);
        condition();
        setState(890);
        match(CPP14Parser::RightParen);
        setState(891);
        statement();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConditionContext ------------------------------------------------------------------

CPP14Parser::ConditionContext::ConditionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ExpressionContext* CPP14Parser::ConditionContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ConditionContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::DeclaratorContext* CPP14Parser::ConditionContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

tree::TerminalNode* CPP14Parser::ConditionContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::InitializerClauseContext* CPP14Parser::ConditionContext::initializerClause() {
  return getRuleContext<CPP14Parser::InitializerClauseContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::ConditionContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ConditionContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::ConditionContext::getRuleIndex() const {
  return CPP14Parser::RuleCondition;
}


std::any CPP14Parser::ConditionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCondition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConditionContext* CPP14Parser::condition() {
  ConditionContext *_localctx = _tracker.createInstance<ConditionContext>(_ctx, getState());
  enterRule(_localctx, 106, CPP14Parser::RuleCondition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(906);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(895);
      expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(897);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
        setState(896);
        attributeSpecifierSeq();
      }
      setState(899);
      declSpecifierSeq();
      setState(900);
      declarator();
      setState(904);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::Assign: {
          setState(901);
          match(CPP14Parser::Assign);
          setState(902);
          initializerClause();
          break;
        }

        case CPP14Parser::LeftBrace: {
          setState(903);
          bracedInitList();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IterationStatementContext ------------------------------------------------------------------

CPP14Parser::IterationStatementContext::IterationStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::While() {
  return getToken(CPP14Parser::While, 0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ConditionContext* CPP14Parser::IterationStatementContext::condition() {
  return getRuleContext<CPP14Parser::ConditionContext>(0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::StatementContext* CPP14Parser::IterationStatementContext::statement() {
  return getRuleContext<CPP14Parser::StatementContext>(0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::Do() {
  return getToken(CPP14Parser::Do, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::IterationStatementContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::For() {
  return getToken(CPP14Parser::For, 0);
}

CPP14Parser::ForInitStatementContext* CPP14Parser::IterationStatementContext::forInitStatement() {
  return getRuleContext<CPP14Parser::ForInitStatementContext>(0);
}

CPP14Parser::ForRangeDeclarationContext* CPP14Parser::IterationStatementContext::forRangeDeclaration() {
  return getRuleContext<CPP14Parser::ForRangeDeclarationContext>(0);
}

tree::TerminalNode* CPP14Parser::IterationStatementContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::ForRangeInitializerContext* CPP14Parser::IterationStatementContext::forRangeInitializer() {
  return getRuleContext<CPP14Parser::ForRangeInitializerContext>(0);
}


size_t CPP14Parser::IterationStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleIterationStatement;
}


std::any CPP14Parser::IterationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitIterationStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::IterationStatementContext* CPP14Parser::iterationStatement() {
  IterationStatementContext *_localctx = _tracker.createInstance<IterationStatementContext>(_ctx, getState());
  enterRule(_localctx, 108, CPP14Parser::RuleIterationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(941);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::While: {
        enterOuterAlt(_localctx, 1);
        setState(908);
        match(CPP14Parser::While);
        setState(909);
        match(CPP14Parser::LeftParen);
        setState(910);
        condition();
        setState(911);
        match(CPP14Parser::RightParen);
        setState(912);
        statement();
        break;
      }

      case CPP14Parser::Do: {
        enterOuterAlt(_localctx, 2);
        setState(914);
        match(CPP14Parser::Do);
        setState(915);
        statement();
        setState(916);
        match(CPP14Parser::While);
        setState(917);
        match(CPP14Parser::LeftParen);
        setState(918);
        expression();
        setState(919);
        match(CPP14Parser::RightParen);
        setState(920);
        match(CPP14Parser::Semi);
        break;
      }

      case CPP14Parser::For: {
        enterOuterAlt(_localctx, 3);
        setState(922);
        match(CPP14Parser::For);
        setState(923);
        match(CPP14Parser::LeftParen);
        setState(936);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
        case 1: {
          setState(924);
          forInitStatement();
          setState(926);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & -714116761242538754) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 65)) & 4719772474384301683) != 0 || _la == CPP14Parser::Identifier) {
            setState(925);
            condition();
          }
          setState(928);
          match(CPP14Parser::Semi);
          setState(930);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 65)) & 4719772474384133201) != 0 || _la == CPP14Parser::Identifier) {
            setState(929);
            expression();
          }
          break;
        }

        case 2: {
          setState(932);
          forRangeDeclaration();
          setState(933);
          match(CPP14Parser::Colon);
          setState(934);
          forRangeInitializer();
          break;
        }

        default:
          break;
        }
        setState(938);
        match(CPP14Parser::RightParen);
        setState(939);
        statement();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ForInitStatementContext ------------------------------------------------------------------

CPP14Parser::ForInitStatementContext::ForInitStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ExpressionStatementContext* CPP14Parser::ForInitStatementContext::expressionStatement() {
  return getRuleContext<CPP14Parser::ExpressionStatementContext>(0);
}

CPP14Parser::SimpleDeclarationContext* CPP14Parser::ForInitStatementContext::simpleDeclaration() {
  return getRuleContext<CPP14Parser::SimpleDeclarationContext>(0);
}


size_t CPP14Parser::ForInitStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleForInitStatement;
}


std::any CPP14Parser::ForInitStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitForInitStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ForInitStatementContext* CPP14Parser::forInitStatement() {
  ForInitStatementContext *_localctx = _tracker.createInstance<ForInitStatementContext>(_ctx, getState());
  enterRule(_localctx, 110, CPP14Parser::RuleForInitStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(945);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(943);
      expressionStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(944);
      simpleDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ForRangeDeclarationContext ------------------------------------------------------------------

CPP14Parser::ForRangeDeclarationContext::ForRangeDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ForRangeDeclarationContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::DeclaratorContext* CPP14Parser::ForRangeDeclarationContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ForRangeDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::ForRangeDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleForRangeDeclaration;
}


std::any CPP14Parser::ForRangeDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitForRangeDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ForRangeDeclarationContext* CPP14Parser::forRangeDeclaration() {
  ForRangeDeclarationContext *_localctx = _tracker.createInstance<ForRangeDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 112, CPP14Parser::RuleForRangeDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(948);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(947);
      attributeSpecifierSeq();
    }
    setState(950);
    declSpecifierSeq();
    setState(951);
    declarator();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ForRangeInitializerContext ------------------------------------------------------------------

CPP14Parser::ForRangeInitializerContext::ForRangeInitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ExpressionContext* CPP14Parser::ForRangeInitializerContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::ForRangeInitializerContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}


size_t CPP14Parser::ForRangeInitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleForRangeInitializer;
}


std::any CPP14Parser::ForRangeInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitForRangeInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ForRangeInitializerContext* CPP14Parser::forRangeInitializer() {
  ForRangeInitializerContext *_localctx = _tracker.createInstance<ForRangeInitializerContext>(_ctx, getState());
  enterRule(_localctx, 114, CPP14Parser::RuleForRangeInitializer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(955);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::IntegerLiteral:
      case CPP14Parser::CharacterLiteral:
      case CPP14Parser::FloatingLiteral:
      case CPP14Parser::StringLiteral:
      case CPP14Parser::BooleanLiteral:
      case CPP14Parser::PointerLiteral:
      case CPP14Parser::UserDefinedLiteral:
      case CPP14Parser::Alignof:
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Const_cast:
      case CPP14Parser::Decltype:
      case CPP14Parser::Delete:
      case CPP14Parser::Double:
      case CPP14Parser::Dynamic_cast:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::New:
      case CPP14Parser::Noexcept:
      case CPP14Parser::Operator:
      case CPP14Parser::Reinterpret_cast:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Sizeof:
      case CPP14Parser::Static_cast:
      case CPP14Parser::This:
      case CPP14Parser::Throw:
      case CPP14Parser::Typeid_:
      case CPP14Parser::Typename_:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Wchar:
      case CPP14Parser::LeftParen:
      case CPP14Parser::LeftBracket:
      case CPP14Parser::Plus:
      case CPP14Parser::Minus:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::Or:
      case CPP14Parser::Tilde:
      case CPP14Parser::Not:
      case CPP14Parser::PlusPlus:
      case CPP14Parser::MinusMinus:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(953);
        expression();
        break;
      }

      case CPP14Parser::LeftBrace: {
        enterOuterAlt(_localctx, 2);
        setState(954);
        bracedInitList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JumpStatementContext ------------------------------------------------------------------

CPP14Parser::JumpStatementContext::JumpStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Break() {
  return getToken(CPP14Parser::Break, 0);
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Continue() {
  return getToken(CPP14Parser::Continue, 0);
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Return() {
  return getToken(CPP14Parser::Return, 0);
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Goto() {
  return getToken(CPP14Parser::Goto, 0);
}

tree::TerminalNode* CPP14Parser::JumpStatementContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::JumpStatementContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::JumpStatementContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}


size_t CPP14Parser::JumpStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleJumpStatement;
}


std::any CPP14Parser::JumpStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitJumpStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::JumpStatementContext* CPP14Parser::jumpStatement() {
  JumpStatementContext *_localctx = _tracker.createInstance<JumpStatementContext>(_ctx, getState());
  enterRule(_localctx, 116, CPP14Parser::RuleJumpStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(966);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Break: {
        setState(957);
        match(CPP14Parser::Break);
        break;
      }

      case CPP14Parser::Continue: {
        setState(958);
        match(CPP14Parser::Continue);
        break;
      }

      case CPP14Parser::Return: {
        setState(959);
        match(CPP14Parser::Return);
        setState(962);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case CPP14Parser::IntegerLiteral:
          case CPP14Parser::CharacterLiteral:
          case CPP14Parser::FloatingLiteral:
          case CPP14Parser::StringLiteral:
          case CPP14Parser::BooleanLiteral:
          case CPP14Parser::PointerLiteral:
          case CPP14Parser::UserDefinedLiteral:
          case CPP14Parser::Alignof:
          case CPP14Parser::Auto:
          case CPP14Parser::Bool:
          case CPP14Parser::Char:
          case CPP14Parser::Char16:
          case CPP14Parser::Char32:
          case CPP14Parser::Const_cast:
          case CPP14Parser::Decltype:
          case CPP14Parser::Delete:
          case CPP14Parser::Double:
          case CPP14Parser::Dynamic_cast:
          case CPP14Parser::Float:
          case CPP14Parser::Int:
          case CPP14Parser::Long:
          case CPP14Parser::New:
          case CPP14Parser::Noexcept:
          case CPP14Parser::Operator:
          case CPP14Parser::Reinterpret_cast:
          case CPP14Parser::Short:
          case CPP14Parser::Signed:
          case CPP14Parser::Sizeof:
          case CPP14Parser::Static_cast:
          case CPP14Parser::This:
          case CPP14Parser::Throw:
          case CPP14Parser::Typeid_:
          case CPP14Parser::Typename_:
          case CPP14Parser::Unsigned:
          case CPP14Parser::Void:
          case CPP14Parser::Wchar:
          case CPP14Parser::LeftParen:
          case CPP14Parser::LeftBracket:
          case CPP14Parser::Plus:
          case CPP14Parser::Minus:
          case CPP14Parser::Star:
          case CPP14Parser::And:
          case CPP14Parser::Or:
          case CPP14Parser::Tilde:
          case CPP14Parser::Not:
          case CPP14Parser::PlusPlus:
          case CPP14Parser::MinusMinus:
          case CPP14Parser::Doublecolon:
          case CPP14Parser::Identifier: {
            setState(960);
            expression();
            break;
          }

          case CPP14Parser::LeftBrace: {
            setState(961);
            bracedInitList();
            break;
          }

          case CPP14Parser::Semi: {
            break;
          }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::Goto: {
        setState(964);
        match(CPP14Parser::Goto);
        setState(965);
        match(CPP14Parser::Identifier);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(968);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclarationStatementContext ------------------------------------------------------------------

CPP14Parser::DeclarationStatementContext::DeclarationStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::BlockDeclarationContext* CPP14Parser::DeclarationStatementContext::blockDeclaration() {
  return getRuleContext<CPP14Parser::BlockDeclarationContext>(0);
}


size_t CPP14Parser::DeclarationStatementContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclarationStatement;
}


std::any CPP14Parser::DeclarationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclarationStatement(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclarationStatementContext* CPP14Parser::declarationStatement() {
  DeclarationStatementContext *_localctx = _tracker.createInstance<DeclarationStatementContext>(_ctx, getState());
  enterRule(_localctx, 118, CPP14Parser::RuleDeclarationStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(970);
    blockDeclaration();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclarationseqContext ------------------------------------------------------------------

CPP14Parser::DeclarationseqContext::DeclarationseqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::DeclarationContext *> CPP14Parser::DeclarationseqContext::declaration() {
  return getRuleContexts<CPP14Parser::DeclarationContext>();
}

CPP14Parser::DeclarationContext* CPP14Parser::DeclarationseqContext::declaration(size_t i) {
  return getRuleContext<CPP14Parser::DeclarationContext>(i);
}


size_t CPP14Parser::DeclarationseqContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclarationseq;
}


std::any CPP14Parser::DeclarationseqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclarationseq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclarationseqContext* CPP14Parser::declarationseq() {
  DeclarationseqContext *_localctx = _tracker.createInstance<DeclarationseqContext>(_ctx, getState());
  enterRule(_localctx, 120, CPP14Parser::RuleDeclarationseq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(973); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(972);
      declaration();
      setState(975); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1543754443169808157) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 459384754220313597) != 0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclarationContext ------------------------------------------------------------------

CPP14Parser::DeclarationContext::DeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::BlockDeclarationContext* CPP14Parser::DeclarationContext::blockDeclaration() {
  return getRuleContext<CPP14Parser::BlockDeclarationContext>(0);
}

CPP14Parser::FunctionDefinitionContext* CPP14Parser::DeclarationContext::functionDefinition() {
  return getRuleContext<CPP14Parser::FunctionDefinitionContext>(0);
}

CPP14Parser::TemplateDeclarationContext* CPP14Parser::DeclarationContext::templateDeclaration() {
  return getRuleContext<CPP14Parser::TemplateDeclarationContext>(0);
}

CPP14Parser::ExplicitInstantiationContext* CPP14Parser::DeclarationContext::explicitInstantiation() {
  return getRuleContext<CPP14Parser::ExplicitInstantiationContext>(0);
}

CPP14Parser::ExplicitSpecializationContext* CPP14Parser::DeclarationContext::explicitSpecialization() {
  return getRuleContext<CPP14Parser::ExplicitSpecializationContext>(0);
}

CPP14Parser::LinkageSpecificationContext* CPP14Parser::DeclarationContext::linkageSpecification() {
  return getRuleContext<CPP14Parser::LinkageSpecificationContext>(0);
}

CPP14Parser::NamespaceDefinitionContext* CPP14Parser::DeclarationContext::namespaceDefinition() {
  return getRuleContext<CPP14Parser::NamespaceDefinitionContext>(0);
}

CPP14Parser::EmptyDeclarationContext* CPP14Parser::DeclarationContext::emptyDeclaration() {
  return getRuleContext<CPP14Parser::EmptyDeclarationContext>(0);
}

CPP14Parser::AttributeDeclarationContext* CPP14Parser::DeclarationContext::attributeDeclaration() {
  return getRuleContext<CPP14Parser::AttributeDeclarationContext>(0);
}


size_t CPP14Parser::DeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclaration;
}


std::any CPP14Parser::DeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclarationContext* CPP14Parser::declaration() {
  DeclarationContext *_localctx = _tracker.createInstance<DeclarationContext>(_ctx, getState());
  enterRule(_localctx, 122, CPP14Parser::RuleDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(986);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(977);
      blockDeclaration();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(978);
      functionDefinition();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(979);
      templateDeclaration();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(980);
      explicitInstantiation();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(981);
      explicitSpecialization();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(982);
      linkageSpecification();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(983);
      namespaceDefinition();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(984);
      emptyDeclaration();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(985);
      attributeDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BlockDeclarationContext ------------------------------------------------------------------

CPP14Parser::BlockDeclarationContext::BlockDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::SimpleDeclarationContext* CPP14Parser::BlockDeclarationContext::simpleDeclaration() {
  return getRuleContext<CPP14Parser::SimpleDeclarationContext>(0);
}

CPP14Parser::AsmDefinitionContext* CPP14Parser::BlockDeclarationContext::asmDefinition() {
  return getRuleContext<CPP14Parser::AsmDefinitionContext>(0);
}

CPP14Parser::NamespaceAliasDefinitionContext* CPP14Parser::BlockDeclarationContext::namespaceAliasDefinition() {
  return getRuleContext<CPP14Parser::NamespaceAliasDefinitionContext>(0);
}

CPP14Parser::UsingDeclarationContext* CPP14Parser::BlockDeclarationContext::usingDeclaration() {
  return getRuleContext<CPP14Parser::UsingDeclarationContext>(0);
}

CPP14Parser::UsingDirectiveContext* CPP14Parser::BlockDeclarationContext::usingDirective() {
  return getRuleContext<CPP14Parser::UsingDirectiveContext>(0);
}

CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::BlockDeclarationContext::staticAssertDeclaration() {
  return getRuleContext<CPP14Parser::StaticAssertDeclarationContext>(0);
}

CPP14Parser::AliasDeclarationContext* CPP14Parser::BlockDeclarationContext::aliasDeclaration() {
  return getRuleContext<CPP14Parser::AliasDeclarationContext>(0);
}

CPP14Parser::OpaqueEnumDeclarationContext* CPP14Parser::BlockDeclarationContext::opaqueEnumDeclaration() {
  return getRuleContext<CPP14Parser::OpaqueEnumDeclarationContext>(0);
}


size_t CPP14Parser::BlockDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleBlockDeclaration;
}


std::any CPP14Parser::BlockDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBlockDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BlockDeclarationContext* CPP14Parser::blockDeclaration() {
  BlockDeclarationContext *_localctx = _tracker.createInstance<BlockDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 124, CPP14Parser::RuleBlockDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(996);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(988);
      simpleDeclaration();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(989);
      asmDefinition();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(990);
      namespaceAliasDefinition();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(991);
      usingDeclaration();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(992);
      usingDirective();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(993);
      staticAssertDeclaration();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(994);
      aliasDeclaration();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(995);
      opaqueEnumDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AliasDeclarationContext ------------------------------------------------------------------

CPP14Parser::AliasDeclarationContext::AliasDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Using() {
  return getToken(CPP14Parser::Using, 0);
}

tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::AliasDeclarationContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::AliasDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::AliasDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::AliasDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleAliasDeclaration;
}


std::any CPP14Parser::AliasDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAliasDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AliasDeclarationContext* CPP14Parser::aliasDeclaration() {
  AliasDeclarationContext *_localctx = _tracker.createInstance<AliasDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 126, CPP14Parser::RuleAliasDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(998);
    match(CPP14Parser::Using);
    setState(999);
    match(CPP14Parser::Identifier);
    setState(1001);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1000);
      attributeSpecifierSeq();
    }
    setState(1003);
    match(CPP14Parser::Assign);
    setState(1004);
    theTypeId();
    setState(1005);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleDeclarationContext ------------------------------------------------------------------

CPP14Parser::SimpleDeclarationContext::SimpleDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::SimpleDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::SimpleDeclarationContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::InitDeclaratorListContext* CPP14Parser::SimpleDeclarationContext::initDeclaratorList() {
  return getRuleContext<CPP14Parser::InitDeclaratorListContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::SimpleDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::SimpleDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleDeclaration;
}


std::any CPP14Parser::SimpleDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleDeclarationContext* CPP14Parser::simpleDeclaration() {
  SimpleDeclarationContext *_localctx = _tracker.createInstance<SimpleDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 128, CPP14Parser::RuleSimpleDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1021);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Constexpr:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Enum:
      case CPP14Parser::Explicit:
      case CPP14Parser::Extern:
      case CPP14Parser::Float:
      case CPP14Parser::Friend:
      case CPP14Parser::Inline:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Mutable:
      case CPP14Parser::Operator:
      case CPP14Parser::Register:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Static:
      case CPP14Parser::Struct:
      case CPP14Parser::Thread_local:
      case CPP14Parser::Typedef:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Virtual:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::LeftParen:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::Tilde:
      case CPP14Parser::AndAnd:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Semi:
      case CPP14Parser::Ellipsis:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(1008);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx)) {
        case 1: {
          setState(1007);
          declSpecifierSeq();
          break;
        }

        default:
          break;
        }
        setState(1011);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Decltype

        || _la == CPP14Parser::Operator || (((_la - 85) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 85)) & 215512868999425) != 0) {
          setState(1010);
          initDeclaratorList();
        }
        setState(1013);
        match(CPP14Parser::Semi);
        break;
      }

      case CPP14Parser::Alignas:
      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 2);
        setState(1014);
        attributeSpecifierSeq();
        setState(1016);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
        case 1: {
          setState(1015);
          declSpecifierSeq();
          break;
        }

        default:
          break;
        }
        setState(1018);
        initDeclaratorList();
        setState(1019);
        match(CPP14Parser::Semi);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StaticAssertDeclarationContext ------------------------------------------------------------------

CPP14Parser::StaticAssertDeclarationContext::StaticAssertDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Static_assert() {
  return getToken(CPP14Parser::Static_assert, 0);
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::StaticAssertDeclarationContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::StringLiteral() {
  return getToken(CPP14Parser::StringLiteral, 0);
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

tree::TerminalNode* CPP14Parser::StaticAssertDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}


size_t CPP14Parser::StaticAssertDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleStaticAssertDeclaration;
}


std::any CPP14Parser::StaticAssertDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitStaticAssertDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::staticAssertDeclaration() {
  StaticAssertDeclarationContext *_localctx = _tracker.createInstance<StaticAssertDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 130, CPP14Parser::RuleStaticAssertDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1023);
    match(CPP14Parser::Static_assert);
    setState(1024);
    match(CPP14Parser::LeftParen);
    setState(1025);
    constantExpression();
    setState(1026);
    match(CPP14Parser::Comma);
    setState(1027);
    match(CPP14Parser::StringLiteral);
    setState(1028);
    match(CPP14Parser::RightParen);
    setState(1029);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EmptyDeclarationContext ------------------------------------------------------------------

CPP14Parser::EmptyDeclarationContext::EmptyDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::EmptyDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}


size_t CPP14Parser::EmptyDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleEmptyDeclaration;
}


std::any CPP14Parser::EmptyDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEmptyDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EmptyDeclarationContext* CPP14Parser::emptyDeclaration() {
  EmptyDeclarationContext *_localctx = _tracker.createInstance<EmptyDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 132, CPP14Parser::RuleEmptyDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1031);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeDeclarationContext ------------------------------------------------------------------

CPP14Parser::AttributeDeclarationContext::AttributeDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::AttributeDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::AttributeDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}


size_t CPP14Parser::AttributeDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeDeclaration;
}


std::any CPP14Parser::AttributeDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeDeclarationContext* CPP14Parser::attributeDeclaration() {
  AttributeDeclarationContext *_localctx = _tracker.createInstance<AttributeDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 134, CPP14Parser::RuleAttributeDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1033);
    attributeSpecifierSeq();
    setState(1034);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclSpecifierContext ------------------------------------------------------------------

CPP14Parser::DeclSpecifierContext::DeclSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::StorageClassSpecifierContext* CPP14Parser::DeclSpecifierContext::storageClassSpecifier() {
  return getRuleContext<CPP14Parser::StorageClassSpecifierContext>(0);
}

CPP14Parser::TypeSpecifierContext* CPP14Parser::DeclSpecifierContext::typeSpecifier() {
  return getRuleContext<CPP14Parser::TypeSpecifierContext>(0);
}

CPP14Parser::FunctionSpecifierContext* CPP14Parser::DeclSpecifierContext::functionSpecifier() {
  return getRuleContext<CPP14Parser::FunctionSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Friend() {
  return getToken(CPP14Parser::Friend, 0);
}

tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Typedef() {
  return getToken(CPP14Parser::Typedef, 0);
}

tree::TerminalNode* CPP14Parser::DeclSpecifierContext::Constexpr() {
  return getToken(CPP14Parser::Constexpr, 0);
}


size_t CPP14Parser::DeclSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclSpecifier;
}


std::any CPP14Parser::DeclSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclSpecifierContext* CPP14Parser::declSpecifier() {
  DeclSpecifierContext *_localctx = _tracker.createInstance<DeclSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 136, CPP14Parser::RuleDeclSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1042);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Extern:
      case CPP14Parser::Mutable:
      case CPP14Parser::Register:
      case CPP14Parser::Static:
      case CPP14Parser::Thread_local: {
        enterOuterAlt(_localctx, 1);
        setState(1036);
        storageClassSpecifier();
        break;
      }

      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Enum:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Struct:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 2);
        setState(1037);
        typeSpecifier();
        break;
      }

      case CPP14Parser::Explicit:
      case CPP14Parser::Inline:
      case CPP14Parser::Virtual: {
        enterOuterAlt(_localctx, 3);
        setState(1038);
        functionSpecifier();
        break;
      }

      case CPP14Parser::Friend: {
        enterOuterAlt(_localctx, 4);
        setState(1039);
        match(CPP14Parser::Friend);
        break;
      }

      case CPP14Parser::Typedef: {
        enterOuterAlt(_localctx, 5);
        setState(1040);
        match(CPP14Parser::Typedef);
        break;
      }

      case CPP14Parser::Constexpr: {
        enterOuterAlt(_localctx, 6);
        setState(1041);
        match(CPP14Parser::Constexpr);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclSpecifierSeqContext ------------------------------------------------------------------

CPP14Parser::DeclSpecifierSeqContext::DeclSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::DeclSpecifierContext *> CPP14Parser::DeclSpecifierSeqContext::declSpecifier() {
  return getRuleContexts<CPP14Parser::DeclSpecifierContext>();
}

CPP14Parser::DeclSpecifierContext* CPP14Parser::DeclSpecifierSeqContext::declSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::DeclSpecifierContext>(i);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::DeclSpecifierSeqContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::DeclSpecifierSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclSpecifierSeq;
}


std::any CPP14Parser::DeclSpecifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclSpecifierSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::declSpecifierSeq() {
  DeclSpecifierSeqContext *_localctx = _tracker.createInstance<DeclSpecifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 138, CPP14Parser::RuleDeclSpecifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1045); 
    _errHandler->sync(this);
    alt = 1 + 1;
    do {
      switch (alt) {
        case 1 + 1: {
              setState(1044);
              declSpecifier();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1047); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx);
    } while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(1050);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
    case 1: {
      setState(1049);
      attributeSpecifierSeq();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StorageClassSpecifierContext ------------------------------------------------------------------

CPP14Parser::StorageClassSpecifierContext::StorageClassSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Register() {
  return getToken(CPP14Parser::Register, 0);
}

tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Static() {
  return getToken(CPP14Parser::Static, 0);
}

tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Thread_local() {
  return getToken(CPP14Parser::Thread_local, 0);
}

tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Extern() {
  return getToken(CPP14Parser::Extern, 0);
}

tree::TerminalNode* CPP14Parser::StorageClassSpecifierContext::Mutable() {
  return getToken(CPP14Parser::Mutable, 0);
}


size_t CPP14Parser::StorageClassSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleStorageClassSpecifier;
}


std::any CPP14Parser::StorageClassSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitStorageClassSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::StorageClassSpecifierContext* CPP14Parser::storageClassSpecifier() {
  StorageClassSpecifierContext *_localctx = _tracker.createInstance<StorageClassSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 140, CPP14Parser::RuleStorageClassSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1052);
    _la = _input->LA(1);
    if (!((((_la - 36) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 36)) & 17316186113) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionSpecifierContext ------------------------------------------------------------------

CPP14Parser::FunctionSpecifierContext::FunctionSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Inline() {
  return getToken(CPP14Parser::Inline, 0);
}

tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Virtual() {
  return getToken(CPP14Parser::Virtual, 0);
}

tree::TerminalNode* CPP14Parser::FunctionSpecifierContext::Explicit() {
  return getToken(CPP14Parser::Explicit, 0);
}


size_t CPP14Parser::FunctionSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleFunctionSpecifier;
}


std::any CPP14Parser::FunctionSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitFunctionSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::FunctionSpecifierContext* CPP14Parser::functionSpecifier() {
  FunctionSpecifierContext *_localctx = _tracker.createInstance<FunctionSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 142, CPP14Parser::RuleFunctionSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1054);
    _la = _input->LA(1);
    if (!((((_la - 34) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 34)) & 70368744178689) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypedefNameContext ------------------------------------------------------------------

CPP14Parser::TypedefNameContext::TypedefNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TypedefNameContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::TypedefNameContext::getRuleIndex() const {
  return CPP14Parser::RuleTypedefName;
}


std::any CPP14Parser::TypedefNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypedefName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypedefNameContext* CPP14Parser::typedefName() {
  TypedefNameContext *_localctx = _tracker.createInstance<TypedefNameContext>(_ctx, getState());
  enterRule(_localctx, 144, CPP14Parser::RuleTypedefName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1056);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::TypeSpecifierContext::TypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::TypeSpecifierContext::trailingTypeSpecifier() {
  return getRuleContext<CPP14Parser::TrailingTypeSpecifierContext>(0);
}

CPP14Parser::ClassSpecifierContext* CPP14Parser::TypeSpecifierContext::classSpecifier() {
  return getRuleContext<CPP14Parser::ClassSpecifierContext>(0);
}

CPP14Parser::EnumSpecifierContext* CPP14Parser::TypeSpecifierContext::enumSpecifier() {
  return getRuleContext<CPP14Parser::EnumSpecifierContext>(0);
}


size_t CPP14Parser::TypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeSpecifier;
}


std::any CPP14Parser::TypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeSpecifierContext* CPP14Parser::typeSpecifier() {
  TypeSpecifierContext *_localctx = _tracker.createInstance<TypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 146, CPP14Parser::RuleTypeSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1061);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1058);
      trailingTypeSpecifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1059);
      classSpecifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1060);
      enumSpecifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TrailingTypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::TrailingTypeSpecifierContext::TrailingTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::simpleTypeSpecifier() {
  return getRuleContext<CPP14Parser::SimpleTypeSpecifierContext>(0);
}

CPP14Parser::ElaboratedTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::elaboratedTypeSpecifier() {
  return getRuleContext<CPP14Parser::ElaboratedTypeSpecifierContext>(0);
}

CPP14Parser::TypeNameSpecifierContext* CPP14Parser::TrailingTypeSpecifierContext::typeNameSpecifier() {
  return getRuleContext<CPP14Parser::TypeNameSpecifierContext>(0);
}

CPP14Parser::CvQualifierContext* CPP14Parser::TrailingTypeSpecifierContext::cvQualifier() {
  return getRuleContext<CPP14Parser::CvQualifierContext>(0);
}


size_t CPP14Parser::TrailingTypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleTrailingTypeSpecifier;
}


std::any CPP14Parser::TrailingTypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTrailingTypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::trailingTypeSpecifier() {
  TrailingTypeSpecifierContext *_localctx = _tracker.createInstance<TrailingTypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 148, CPP14Parser::RuleTrailingTypeSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1067);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Wchar:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(1063);
        simpleTypeSpecifier();
        break;
      }

      case CPP14Parser::Class:
      case CPP14Parser::Enum:
      case CPP14Parser::Struct: {
        enterOuterAlt(_localctx, 2);
        setState(1064);
        elaboratedTypeSpecifier();
        break;
      }

      case CPP14Parser::Typename_: {
        enterOuterAlt(_localctx, 3);
        setState(1065);
        typeNameSpecifier();
        break;
      }

      case CPP14Parser::Const:
      case CPP14Parser::Volatile: {
        enterOuterAlt(_localctx, 4);
        setState(1066);
        cvQualifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeSpecifierSeqContext ------------------------------------------------------------------

CPP14Parser::TypeSpecifierSeqContext::TypeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::TypeSpecifierContext *> CPP14Parser::TypeSpecifierSeqContext::typeSpecifier() {
  return getRuleContexts<CPP14Parser::TypeSpecifierContext>();
}

CPP14Parser::TypeSpecifierContext* CPP14Parser::TypeSpecifierSeqContext::typeSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::TypeSpecifierContext>(i);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::TypeSpecifierSeqContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::TypeSpecifierSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeSpecifierSeq;
}


std::any CPP14Parser::TypeSpecifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeSpecifierSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::typeSpecifierSeq() {
  TypeSpecifierSeqContext *_localctx = _tracker.createInstance<TypeSpecifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 150, CPP14Parser::RuleTypeSpecifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1070); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1069);
              typeSpecifier();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1072); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(1075);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx)) {
    case 1: {
      setState(1074);
      attributeSpecifierSeq();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TrailingTypeSpecifierSeqContext ------------------------------------------------------------------

CPP14Parser::TrailingTypeSpecifierSeqContext::TrailingTypeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::TrailingTypeSpecifierContext *> CPP14Parser::TrailingTypeSpecifierSeqContext::trailingTypeSpecifier() {
  return getRuleContexts<CPP14Parser::TrailingTypeSpecifierContext>();
}

CPP14Parser::TrailingTypeSpecifierContext* CPP14Parser::TrailingTypeSpecifierSeqContext::trailingTypeSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::TrailingTypeSpecifierContext>(i);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::TrailingTypeSpecifierSeqContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::TrailingTypeSpecifierSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleTrailingTypeSpecifierSeq;
}


std::any CPP14Parser::TrailingTypeSpecifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTrailingTypeSpecifierSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TrailingTypeSpecifierSeqContext* CPP14Parser::trailingTypeSpecifierSeq() {
  TrailingTypeSpecifierSeqContext *_localctx = _tracker.createInstance<TrailingTypeSpecifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 152, CPP14Parser::RuleTrailingTypeSpecifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1078); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1077);
              trailingTypeSpecifier();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1080); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(1083);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx)) {
    case 1: {
      setState(1082);
      attributeSpecifierSeq();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleTypeLengthModifierContext ------------------------------------------------------------------

CPP14Parser::SimpleTypeLengthModifierContext::SimpleTypeLengthModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::SimpleTypeLengthModifierContext::Short() {
  return getToken(CPP14Parser::Short, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeLengthModifierContext::Long() {
  return getToken(CPP14Parser::Long, 0);
}


size_t CPP14Parser::SimpleTypeLengthModifierContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleTypeLengthModifier;
}


std::any CPP14Parser::SimpleTypeLengthModifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleTypeLengthModifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleTypeLengthModifierContext* CPP14Parser::simpleTypeLengthModifier() {
  SimpleTypeLengthModifierContext *_localctx = _tracker.createInstance<SimpleTypeLengthModifierContext>(_ctx, getState());
  enterRule(_localctx, 154, CPP14Parser::RuleSimpleTypeLengthModifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1085);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::Long

    || _la == CPP14Parser::Short)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleTypeSignednessModifierContext ------------------------------------------------------------------

CPP14Parser::SimpleTypeSignednessModifierContext::SimpleTypeSignednessModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::SimpleTypeSignednessModifierContext::Unsigned() {
  return getToken(CPP14Parser::Unsigned, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSignednessModifierContext::Signed() {
  return getToken(CPP14Parser::Signed, 0);
}


size_t CPP14Parser::SimpleTypeSignednessModifierContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleTypeSignednessModifier;
}


std::any CPP14Parser::SimpleTypeSignednessModifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleTypeSignednessModifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleTypeSignednessModifierContext* CPP14Parser::simpleTypeSignednessModifier() {
  SimpleTypeSignednessModifierContext *_localctx = _tracker.createInstance<SimpleTypeSignednessModifierContext>(_ctx, getState());
  enterRule(_localctx, 156, CPP14Parser::RuleSimpleTypeSignednessModifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1087);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::Signed

    || _la == CPP14Parser::Unsigned)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleTypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::SimpleTypeSpecifierContext::SimpleTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TheTypeNameContext* CPP14Parser::SimpleTypeSpecifierContext::theTypeName() {
  return getRuleContext<CPP14Parser::TheTypeNameContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::SimpleTypeSpecifierContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

CPP14Parser::SimpleTypeSignednessModifierContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTypeSignednessModifier() {
  return getRuleContext<CPP14Parser::SimpleTypeSignednessModifierContext>(0);
}

std::vector<CPP14Parser::SimpleTypeLengthModifierContext *> CPP14Parser::SimpleTypeSpecifierContext::simpleTypeLengthModifier() {
  return getRuleContexts<CPP14Parser::SimpleTypeLengthModifierContext>();
}

CPP14Parser::SimpleTypeLengthModifierContext* CPP14Parser::SimpleTypeSpecifierContext::simpleTypeLengthModifier(size_t i) {
  return getRuleContext<CPP14Parser::SimpleTypeLengthModifierContext>(i);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char() {
  return getToken(CPP14Parser::Char, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char16() {
  return getToken(CPP14Parser::Char16, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Char32() {
  return getToken(CPP14Parser::Char32, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Wchar() {
  return getToken(CPP14Parser::Wchar, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Bool() {
  return getToken(CPP14Parser::Bool, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Int() {
  return getToken(CPP14Parser::Int, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Float() {
  return getToken(CPP14Parser::Float, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Double() {
  return getToken(CPP14Parser::Double, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Void() {
  return getToken(CPP14Parser::Void, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTypeSpecifierContext::Auto() {
  return getToken(CPP14Parser::Auto, 0);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::SimpleTypeSpecifierContext::decltypeSpecifier() {
  return getRuleContext<CPP14Parser::DecltypeSpecifierContext>(0);
}


size_t CPP14Parser::SimpleTypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleTypeSpecifier;
}


std::any CPP14Parser::SimpleTypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleTypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleTypeSpecifierContext* CPP14Parser::simpleTypeSpecifier() {
  SimpleTypeSpecifierContext *_localctx = _tracker.createInstance<SimpleTypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 158, CPP14Parser::RuleSimpleTypeSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1141);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 122, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1090);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
      case 1: {
        setState(1089);
        nestedNameSpecifier(0);
        break;
      }

      default:
        break;
      }
      setState(1092);
      theTypeName();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1093);
      nestedNameSpecifier(0);
      setState(1094);
      match(CPP14Parser::Template);
      setState(1095);
      simpleTemplateId();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1097);
      simpleTypeSignednessModifier();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1099);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1098);
        simpleTypeSignednessModifier();
      }
      setState(1102); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1101);
                simpleTypeLengthModifier();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1104); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1107);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1106);
        simpleTypeSignednessModifier();
      }
      setState(1109);
      match(CPP14Parser::Char);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1111);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1110);
        simpleTypeSignednessModifier();
      }
      setState(1113);
      match(CPP14Parser::Char16);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1115);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1114);
        simpleTypeSignednessModifier();
      }
      setState(1117);
      match(CPP14Parser::Char32);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1119);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1118);
        simpleTypeSignednessModifier();
      }
      setState(1121);
      match(CPP14Parser::Wchar);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1122);
      match(CPP14Parser::Bool);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1124);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Signed

      || _la == CPP14Parser::Unsigned) {
        setState(1123);
        simpleTypeSignednessModifier();
      }
      setState(1129);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CPP14Parser::Long

      || _la == CPP14Parser::Short) {
        setState(1126);
        simpleTypeLengthModifier();
        setState(1131);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1132);
      match(CPP14Parser::Int);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1133);
      match(CPP14Parser::Float);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1135);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Long

      || _la == CPP14Parser::Short) {
        setState(1134);
        simpleTypeLengthModifier();
      }
      setState(1137);
      match(CPP14Parser::Double);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1138);
      match(CPP14Parser::Void);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1139);
      match(CPP14Parser::Auto);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(1140);
      decltypeSpecifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TheTypeNameContext ------------------------------------------------------------------

CPP14Parser::TheTypeNameContext::TheTypeNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassNameContext* CPP14Parser::TheTypeNameContext::className() {
  return getRuleContext<CPP14Parser::ClassNameContext>(0);
}

CPP14Parser::EnumNameContext* CPP14Parser::TheTypeNameContext::enumName() {
  return getRuleContext<CPP14Parser::EnumNameContext>(0);
}

CPP14Parser::TypedefNameContext* CPP14Parser::TheTypeNameContext::typedefName() {
  return getRuleContext<CPP14Parser::TypedefNameContext>(0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TheTypeNameContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}


size_t CPP14Parser::TheTypeNameContext::getRuleIndex() const {
  return CPP14Parser::RuleTheTypeName;
}


std::any CPP14Parser::TheTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTheTypeName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TheTypeNameContext* CPP14Parser::theTypeName() {
  TheTypeNameContext *_localctx = _tracker.createInstance<TheTypeNameContext>(_ctx, getState());
  enterRule(_localctx, 160, CPP14Parser::RuleTheTypeName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1147);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1143);
      className();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1144);
      enumName();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1145);
      typedefName();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1146);
      simpleTemplateId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DecltypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::DecltypeSpecifierContext::DecltypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::Decltype() {
  return getToken(CPP14Parser::Decltype, 0);
}

tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::ExpressionContext* CPP14Parser::DecltypeSpecifierContext::expression() {
  return getRuleContext<CPP14Parser::ExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::DecltypeSpecifierContext::Auto() {
  return getToken(CPP14Parser::Auto, 0);
}


size_t CPP14Parser::DecltypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleDecltypeSpecifier;
}


std::any CPP14Parser::DecltypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDecltypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::decltypeSpecifier() {
  DecltypeSpecifierContext *_localctx = _tracker.createInstance<DecltypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 162, CPP14Parser::RuleDecltypeSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1149);
    match(CPP14Parser::Decltype);
    setState(1150);
    match(CPP14Parser::LeftParen);
    setState(1153);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      setState(1151);
      expression();
      break;
    }

    case 2: {
      setState(1152);
      match(CPP14Parser::Auto);
      break;
    }

    default:
      break;
    }
    setState(1155);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElaboratedTypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::ElaboratedTypeSpecifierContext::ElaboratedTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassKeyContext* CPP14Parser::ElaboratedTypeSpecifierContext::classKey() {
  return getRuleContext<CPP14Parser::ClassKeyContext>(0);
}

tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::ElaboratedTypeSpecifierContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ElaboratedTypeSpecifierContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ElaboratedTypeSpecifierContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

tree::TerminalNode* CPP14Parser::ElaboratedTypeSpecifierContext::Enum() {
  return getToken(CPP14Parser::Enum, 0);
}


size_t CPP14Parser::ElaboratedTypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleElaboratedTypeSpecifier;
}


std::any CPP14Parser::ElaboratedTypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitElaboratedTypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ElaboratedTypeSpecifierContext* CPP14Parser::elaboratedTypeSpecifier() {
  ElaboratedTypeSpecifierContext *_localctx = _tracker.createInstance<ElaboratedTypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 164, CPP14Parser::RuleElaboratedTypeSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1179);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Class:
      case CPP14Parser::Struct: {
        enterOuterAlt(_localctx, 1);
        setState(1157);
        classKey();
        setState(1172);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx)) {
        case 1: {
          setState(1159);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
            setState(1158);
            attributeSpecifierSeq();
          }
          setState(1162);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 126, _ctx)) {
          case 1: {
            setState(1161);
            nestedNameSpecifier(0);
            break;
          }

          default:
            break;
          }
          setState(1164);
          match(CPP14Parser::Identifier);
          break;
        }

        case 2: {
          setState(1165);
          simpleTemplateId();
          break;
        }

        case 3: {
          setState(1166);
          nestedNameSpecifier(0);
          setState(1168);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CPP14Parser::Template) {
            setState(1167);
            match(CPP14Parser::Template);
          }
          setState(1170);
          simpleTemplateId();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::Enum: {
        enterOuterAlt(_localctx, 2);
        setState(1174);
        match(CPP14Parser::Enum);
        setState(1176);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
        case 1: {
          setState(1175);
          nestedNameSpecifier(0);
          break;
        }

        default:
          break;
        }
        setState(1178);
        match(CPP14Parser::Identifier);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumNameContext ------------------------------------------------------------------

CPP14Parser::EnumNameContext::EnumNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::EnumNameContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::EnumNameContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumName;
}


std::any CPP14Parser::EnumNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumNameContext* CPP14Parser::enumName() {
  EnumNameContext *_localctx = _tracker.createInstance<EnumNameContext>(_ctx, getState());
  enterRule(_localctx, 166, CPP14Parser::RuleEnumName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1181);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumSpecifierContext ------------------------------------------------------------------

CPP14Parser::EnumSpecifierContext::EnumSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::EnumHeadContext* CPP14Parser::EnumSpecifierContext::enumHead() {
  return getRuleContext<CPP14Parser::EnumHeadContext>(0);
}

tree::TerminalNode* CPP14Parser::EnumSpecifierContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::EnumSpecifierContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

CPP14Parser::EnumeratorListContext* CPP14Parser::EnumSpecifierContext::enumeratorList() {
  return getRuleContext<CPP14Parser::EnumeratorListContext>(0);
}

tree::TerminalNode* CPP14Parser::EnumSpecifierContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}


size_t CPP14Parser::EnumSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumSpecifier;
}


std::any CPP14Parser::EnumSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumSpecifierContext* CPP14Parser::enumSpecifier() {
  EnumSpecifierContext *_localctx = _tracker.createInstance<EnumSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 168, CPP14Parser::RuleEnumSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1183);
    enumHead();
    setState(1184);
    match(CPP14Parser::LeftBrace);
    setState(1189);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Identifier) {
      setState(1185);
      enumeratorList();
      setState(1187);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Comma) {
        setState(1186);
        match(CPP14Parser::Comma);
      }
    }
    setState(1191);
    match(CPP14Parser::RightBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumHeadContext ------------------------------------------------------------------

CPP14Parser::EnumHeadContext::EnumHeadContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::EnumkeyContext* CPP14Parser::EnumHeadContext::enumkey() {
  return getRuleContext<CPP14Parser::EnumkeyContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::EnumHeadContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::EnumHeadContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::EnumbaseContext* CPP14Parser::EnumHeadContext::enumbase() {
  return getRuleContext<CPP14Parser::EnumbaseContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::EnumHeadContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}


size_t CPP14Parser::EnumHeadContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumHead;
}


std::any CPP14Parser::EnumHeadContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumHead(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumHeadContext* CPP14Parser::enumHead() {
  EnumHeadContext *_localctx = _tracker.createInstance<EnumHeadContext>(_ctx, getState());
  enterRule(_localctx, 170, CPP14Parser::RuleEnumHead);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1193);
    enumkey();
    setState(1195);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1194);
      attributeSpecifierSeq();
    }
    setState(1201);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon

    || _la == CPP14Parser::Identifier) {
      setState(1198);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx)) {
      case 1: {
        setState(1197);
        nestedNameSpecifier(0);
        break;
      }

      default:
        break;
      }
      setState(1200);
      match(CPP14Parser::Identifier);
    }
    setState(1204);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Colon) {
      setState(1203);
      enumbase();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OpaqueEnumDeclarationContext ------------------------------------------------------------------

CPP14Parser::OpaqueEnumDeclarationContext::OpaqueEnumDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::EnumkeyContext* CPP14Parser::OpaqueEnumDeclarationContext::enumkey() {
  return getRuleContext<CPP14Parser::EnumkeyContext>(0);
}

tree::TerminalNode* CPP14Parser::OpaqueEnumDeclarationContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::OpaqueEnumDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::OpaqueEnumDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::EnumbaseContext* CPP14Parser::OpaqueEnumDeclarationContext::enumbase() {
  return getRuleContext<CPP14Parser::EnumbaseContext>(0);
}


size_t CPP14Parser::OpaqueEnumDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleOpaqueEnumDeclaration;
}


std::any CPP14Parser::OpaqueEnumDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitOpaqueEnumDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::OpaqueEnumDeclarationContext* CPP14Parser::opaqueEnumDeclaration() {
  OpaqueEnumDeclarationContext *_localctx = _tracker.createInstance<OpaqueEnumDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 172, CPP14Parser::RuleOpaqueEnumDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1206);
    enumkey();
    setState(1208);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1207);
      attributeSpecifierSeq();
    }
    setState(1210);
    match(CPP14Parser::Identifier);
    setState(1212);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Colon) {
      setState(1211);
      enumbase();
    }
    setState(1214);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumkeyContext ------------------------------------------------------------------

CPP14Parser::EnumkeyContext::EnumkeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::EnumkeyContext::Enum() {
  return getToken(CPP14Parser::Enum, 0);
}

tree::TerminalNode* CPP14Parser::EnumkeyContext::Class() {
  return getToken(CPP14Parser::Class, 0);
}

tree::TerminalNode* CPP14Parser::EnumkeyContext::Struct() {
  return getToken(CPP14Parser::Struct, 0);
}


size_t CPP14Parser::EnumkeyContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumkey;
}


std::any CPP14Parser::EnumkeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumkey(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumkeyContext* CPP14Parser::enumkey() {
  EnumkeyContext *_localctx = _tracker.createInstance<EnumkeyContext>(_ctx, getState());
  enterRule(_localctx, 174, CPP14Parser::RuleEnumkey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1216);
    match(CPP14Parser::Enum);
    setState(1218);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Class

    || _la == CPP14Parser::Struct) {
      setState(1217);
      _la = _input->LA(1);
      if (!(_la == CPP14Parser::Class

      || _la == CPP14Parser::Struct)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumbaseContext ------------------------------------------------------------------

CPP14Parser::EnumbaseContext::EnumbaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::EnumbaseContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::EnumbaseContext::typeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TypeSpecifierSeqContext>(0);
}


size_t CPP14Parser::EnumbaseContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumbase;
}


std::any CPP14Parser::EnumbaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumbase(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumbaseContext* CPP14Parser::enumbase() {
  EnumbaseContext *_localctx = _tracker.createInstance<EnumbaseContext>(_ctx, getState());
  enterRule(_localctx, 176, CPP14Parser::RuleEnumbase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1220);
    match(CPP14Parser::Colon);
    setState(1221);
    typeSpecifierSeq();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumeratorListContext ------------------------------------------------------------------

CPP14Parser::EnumeratorListContext::EnumeratorListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::EnumeratorDefinitionContext *> CPP14Parser::EnumeratorListContext::enumeratorDefinition() {
  return getRuleContexts<CPP14Parser::EnumeratorDefinitionContext>();
}

CPP14Parser::EnumeratorDefinitionContext* CPP14Parser::EnumeratorListContext::enumeratorDefinition(size_t i) {
  return getRuleContext<CPP14Parser::EnumeratorDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::EnumeratorListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::EnumeratorListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::EnumeratorListContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumeratorList;
}


std::any CPP14Parser::EnumeratorListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumeratorList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumeratorListContext* CPP14Parser::enumeratorList() {
  EnumeratorListContext *_localctx = _tracker.createInstance<EnumeratorListContext>(_ctx, getState());
  enterRule(_localctx, 178, CPP14Parser::RuleEnumeratorList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1223);
    enumeratorDefinition();
    setState(1228);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1224);
        match(CPP14Parser::Comma);
        setState(1225);
        enumeratorDefinition(); 
      }
      setState(1230);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumeratorDefinitionContext ------------------------------------------------------------------

CPP14Parser::EnumeratorDefinitionContext::EnumeratorDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::EnumeratorContext* CPP14Parser::EnumeratorDefinitionContext::enumerator() {
  return getRuleContext<CPP14Parser::EnumeratorContext>(0);
}

tree::TerminalNode* CPP14Parser::EnumeratorDefinitionContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::EnumeratorDefinitionContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}


size_t CPP14Parser::EnumeratorDefinitionContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumeratorDefinition;
}


std::any CPP14Parser::EnumeratorDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumeratorDefinition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumeratorDefinitionContext* CPP14Parser::enumeratorDefinition() {
  EnumeratorDefinitionContext *_localctx = _tracker.createInstance<EnumeratorDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 180, CPP14Parser::RuleEnumeratorDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1231);
    enumerator();
    setState(1234);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Assign) {
      setState(1232);
      match(CPP14Parser::Assign);
      setState(1233);
      constantExpression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EnumeratorContext ------------------------------------------------------------------

CPP14Parser::EnumeratorContext::EnumeratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::EnumeratorContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::EnumeratorContext::getRuleIndex() const {
  return CPP14Parser::RuleEnumerator;
}


std::any CPP14Parser::EnumeratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitEnumerator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::EnumeratorContext* CPP14Parser::enumerator() {
  EnumeratorContext *_localctx = _tracker.createInstance<EnumeratorContext>(_ctx, getState());
  enterRule(_localctx, 182, CPP14Parser::RuleEnumerator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1236);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamespaceNameContext ------------------------------------------------------------------

CPP14Parser::NamespaceNameContext::NamespaceNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::NamespaceNameContext::originalNamespaceName() {
  return getRuleContext<CPP14Parser::OriginalNamespaceNameContext>(0);
}

CPP14Parser::NamespaceAliasContext* CPP14Parser::NamespaceNameContext::namespaceAlias() {
  return getRuleContext<CPP14Parser::NamespaceAliasContext>(0);
}


size_t CPP14Parser::NamespaceNameContext::getRuleIndex() const {
  return CPP14Parser::RuleNamespaceName;
}


std::any CPP14Parser::NamespaceNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNamespaceName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NamespaceNameContext* CPP14Parser::namespaceName() {
  NamespaceNameContext *_localctx = _tracker.createInstance<NamespaceNameContext>(_ctx, getState());
  enterRule(_localctx, 184, CPP14Parser::RuleNamespaceName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1240);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1238);
      originalNamespaceName();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1239);
      namespaceAlias();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OriginalNamespaceNameContext ------------------------------------------------------------------

CPP14Parser::OriginalNamespaceNameContext::OriginalNamespaceNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::OriginalNamespaceNameContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::OriginalNamespaceNameContext::getRuleIndex() const {
  return CPP14Parser::RuleOriginalNamespaceName;
}


std::any CPP14Parser::OriginalNamespaceNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitOriginalNamespaceName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::originalNamespaceName() {
  OriginalNamespaceNameContext *_localctx = _tracker.createInstance<OriginalNamespaceNameContext>(_ctx, getState());
  enterRule(_localctx, 186, CPP14Parser::RuleOriginalNamespaceName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1242);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamespaceDefinitionContext ------------------------------------------------------------------

CPP14Parser::NamespaceDefinitionContext::NamespaceDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Namespace() {
  return getToken(CPP14Parser::Namespace, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Inline() {
  return getToken(CPP14Parser::Inline, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceDefinitionContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::OriginalNamespaceNameContext* CPP14Parser::NamespaceDefinitionContext::originalNamespaceName() {
  return getRuleContext<CPP14Parser::OriginalNamespaceNameContext>(0);
}

CPP14Parser::DeclarationseqContext* CPP14Parser::NamespaceDefinitionContext::declarationseq() {
  return getRuleContext<CPP14Parser::DeclarationseqContext>(0);
}


size_t CPP14Parser::NamespaceDefinitionContext::getRuleIndex() const {
  return CPP14Parser::RuleNamespaceDefinition;
}


std::any CPP14Parser::NamespaceDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNamespaceDefinition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NamespaceDefinitionContext* CPP14Parser::namespaceDefinition() {
  NamespaceDefinitionContext *_localctx = _tracker.createInstance<NamespaceDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 188, CPP14Parser::RuleNamespaceDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1245);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Inline) {
      setState(1244);
      match(CPP14Parser::Inline);
    }
    setState(1247);
    match(CPP14Parser::Namespace);
    setState(1250);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 144, _ctx)) {
    case 1: {
      setState(1248);
      match(CPP14Parser::Identifier);
      break;
    }

    case 2: {
      setState(1249);
      originalNamespaceName();
      break;
    }

    default:
      break;
    }
    setState(1252);
    match(CPP14Parser::LeftBrace);
    setState(1254);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1543754443169808157) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 459384754220313597) != 0) {
      setState(1253);
      antlrcpp::downCast<NamespaceDefinitionContext *>(_localctx)->namespaceBody = declarationseq();
    }
    setState(1256);
    match(CPP14Parser::RightBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamespaceAliasContext ------------------------------------------------------------------

CPP14Parser::NamespaceAliasContext::NamespaceAliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NamespaceAliasContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::NamespaceAliasContext::getRuleIndex() const {
  return CPP14Parser::RuleNamespaceAlias;
}


std::any CPP14Parser::NamespaceAliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNamespaceAlias(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NamespaceAliasContext* CPP14Parser::namespaceAlias() {
  NamespaceAliasContext *_localctx = _tracker.createInstance<NamespaceAliasContext>(_ctx, getState());
  enterRule(_localctx, 190, CPP14Parser::RuleNamespaceAlias);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1258);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamespaceAliasDefinitionContext ------------------------------------------------------------------

CPP14Parser::NamespaceAliasDefinitionContext::NamespaceAliasDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Namespace() {
  return getToken(CPP14Parser::Namespace, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::QualifiednamespacespecifierContext* CPP14Parser::NamespaceAliasDefinitionContext::qualifiednamespacespecifier() {
  return getRuleContext<CPP14Parser::QualifiednamespacespecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::NamespaceAliasDefinitionContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}


size_t CPP14Parser::NamespaceAliasDefinitionContext::getRuleIndex() const {
  return CPP14Parser::RuleNamespaceAliasDefinition;
}


std::any CPP14Parser::NamespaceAliasDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNamespaceAliasDefinition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NamespaceAliasDefinitionContext* CPP14Parser::namespaceAliasDefinition() {
  NamespaceAliasDefinitionContext *_localctx = _tracker.createInstance<NamespaceAliasDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 192, CPP14Parser::RuleNamespaceAliasDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1260);
    match(CPP14Parser::Namespace);
    setState(1261);
    match(CPP14Parser::Identifier);
    setState(1262);
    match(CPP14Parser::Assign);
    setState(1263);
    qualifiednamespacespecifier();
    setState(1264);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QualifiednamespacespecifierContext ------------------------------------------------------------------

CPP14Parser::QualifiednamespacespecifierContext::QualifiednamespacespecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::NamespaceNameContext* CPP14Parser::QualifiednamespacespecifierContext::namespaceName() {
  return getRuleContext<CPP14Parser::NamespaceNameContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::QualifiednamespacespecifierContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}


size_t CPP14Parser::QualifiednamespacespecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleQualifiednamespacespecifier;
}


std::any CPP14Parser::QualifiednamespacespecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitQualifiednamespacespecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::QualifiednamespacespecifierContext* CPP14Parser::qualifiednamespacespecifier() {
  QualifiednamespacespecifierContext *_localctx = _tracker.createInstance<QualifiednamespacespecifierContext>(_ctx, getState());
  enterRule(_localctx, 194, CPP14Parser::RuleQualifiednamespacespecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1267);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 146, _ctx)) {
    case 1: {
      setState(1266);
      nestedNameSpecifier(0);
      break;
    }

    default:
      break;
    }
    setState(1269);
    namespaceName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UsingDeclarationContext ------------------------------------------------------------------

CPP14Parser::UsingDeclarationContext::UsingDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Using() {
  return getToken(CPP14Parser::Using, 0);
}

CPP14Parser::UnqualifiedIdContext* CPP14Parser::UsingDeclarationContext::unqualifiedId() {
  return getRuleContext<CPP14Parser::UnqualifiedIdContext>(0);
}

tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::UsingDeclarationContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::UsingDeclarationContext::Typename_() {
  return getToken(CPP14Parser::Typename_, 0);
}


size_t CPP14Parser::UsingDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleUsingDeclaration;
}


std::any CPP14Parser::UsingDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitUsingDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::UsingDeclarationContext* CPP14Parser::usingDeclaration() {
  UsingDeclarationContext *_localctx = _tracker.createInstance<UsingDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 196, CPP14Parser::RuleUsingDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1271);
    match(CPP14Parser::Using);
    setState(1277);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _ctx)) {
    case 1: {
      setState(1273);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Typename_) {
        setState(1272);
        match(CPP14Parser::Typename_);
      }
      setState(1275);
      nestedNameSpecifier(0);
      break;
    }

    case 2: {
      setState(1276);
      match(CPP14Parser::Doublecolon);
      break;
    }

    default:
      break;
    }
    setState(1279);
    unqualifiedId();
    setState(1280);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UsingDirectiveContext ------------------------------------------------------------------

CPP14Parser::UsingDirectiveContext::UsingDirectiveContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Using() {
  return getToken(CPP14Parser::Using, 0);
}

tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Namespace() {
  return getToken(CPP14Parser::Namespace, 0);
}

CPP14Parser::NamespaceNameContext* CPP14Parser::UsingDirectiveContext::namespaceName() {
  return getRuleContext<CPP14Parser::NamespaceNameContext>(0);
}

tree::TerminalNode* CPP14Parser::UsingDirectiveContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::UsingDirectiveContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::UsingDirectiveContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}


size_t CPP14Parser::UsingDirectiveContext::getRuleIndex() const {
  return CPP14Parser::RuleUsingDirective;
}


std::any CPP14Parser::UsingDirectiveContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitUsingDirective(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::UsingDirectiveContext* CPP14Parser::usingDirective() {
  UsingDirectiveContext *_localctx = _tracker.createInstance<UsingDirectiveContext>(_ctx, getState());
  enterRule(_localctx, 198, CPP14Parser::RuleUsingDirective);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1283);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1282);
      attributeSpecifierSeq();
    }
    setState(1285);
    match(CPP14Parser::Using);
    setState(1286);
    match(CPP14Parser::Namespace);
    setState(1288);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx)) {
    case 1: {
      setState(1287);
      nestedNameSpecifier(0);
      break;
    }

    default:
      break;
    }
    setState(1290);
    namespaceName();
    setState(1291);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AsmDefinitionContext ------------------------------------------------------------------

CPP14Parser::AsmDefinitionContext::AsmDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AsmDefinitionContext::Asm() {
  return getToken(CPP14Parser::Asm, 0);
}

tree::TerminalNode* CPP14Parser::AsmDefinitionContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::AsmDefinitionContext::StringLiteral() {
  return getToken(CPP14Parser::StringLiteral, 0);
}

tree::TerminalNode* CPP14Parser::AsmDefinitionContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

tree::TerminalNode* CPP14Parser::AsmDefinitionContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}


size_t CPP14Parser::AsmDefinitionContext::getRuleIndex() const {
  return CPP14Parser::RuleAsmDefinition;
}


std::any CPP14Parser::AsmDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAsmDefinition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AsmDefinitionContext* CPP14Parser::asmDefinition() {
  AsmDefinitionContext *_localctx = _tracker.createInstance<AsmDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 200, CPP14Parser::RuleAsmDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1293);
    match(CPP14Parser::Asm);
    setState(1294);
    match(CPP14Parser::LeftParen);
    setState(1295);
    match(CPP14Parser::StringLiteral);
    setState(1296);
    match(CPP14Parser::RightParen);
    setState(1297);
    match(CPP14Parser::Semi);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LinkageSpecificationContext ------------------------------------------------------------------

CPP14Parser::LinkageSpecificationContext::LinkageSpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::Extern() {
  return getToken(CPP14Parser::Extern, 0);
}

tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::StringLiteral() {
  return getToken(CPP14Parser::StringLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::LinkageSpecificationContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

CPP14Parser::DeclarationContext* CPP14Parser::LinkageSpecificationContext::declaration() {
  return getRuleContext<CPP14Parser::DeclarationContext>(0);
}

CPP14Parser::DeclarationseqContext* CPP14Parser::LinkageSpecificationContext::declarationseq() {
  return getRuleContext<CPP14Parser::DeclarationseqContext>(0);
}


size_t CPP14Parser::LinkageSpecificationContext::getRuleIndex() const {
  return CPP14Parser::RuleLinkageSpecification;
}


std::any CPP14Parser::LinkageSpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLinkageSpecification(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LinkageSpecificationContext* CPP14Parser::linkageSpecification() {
  LinkageSpecificationContext *_localctx = _tracker.createInstance<LinkageSpecificationContext>(_ctx, getState());
  enterRule(_localctx, 202, CPP14Parser::RuleLinkageSpecification);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1299);
    match(CPP14Parser::Extern);
    setState(1300);
    match(CPP14Parser::StringLiteral);
    setState(1307);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftBrace: {
        setState(1301);
        match(CPP14Parser::LeftBrace);
        setState(1303);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la - 10) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 10)) & 1543754443169808157) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 74)) & 459384754220313597) != 0) {
          setState(1302);
          declarationseq();
        }
        setState(1305);
        match(CPP14Parser::RightBrace);
        break;
      }

      case CPP14Parser::Alignas:
      case CPP14Parser::Asm:
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Constexpr:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Enum:
      case CPP14Parser::Explicit:
      case CPP14Parser::Extern:
      case CPP14Parser::Float:
      case CPP14Parser::Friend:
      case CPP14Parser::Inline:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Mutable:
      case CPP14Parser::Namespace:
      case CPP14Parser::Operator:
      case CPP14Parser::Register:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Static:
      case CPP14Parser::Static_assert:
      case CPP14Parser::Struct:
      case CPP14Parser::Template:
      case CPP14Parser::Thread_local:
      case CPP14Parser::Typedef:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Using:
      case CPP14Parser::Virtual:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::LeftParen:
      case CPP14Parser::LeftBracket:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::Tilde:
      case CPP14Parser::AndAnd:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Semi:
      case CPP14Parser::Ellipsis:
      case CPP14Parser::Identifier: {
        setState(1306);
        declaration();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeSpecifierSeqContext ------------------------------------------------------------------

CPP14Parser::AttributeSpecifierSeqContext::AttributeSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::AttributeSpecifierContext *> CPP14Parser::AttributeSpecifierSeqContext::attributeSpecifier() {
  return getRuleContexts<CPP14Parser::AttributeSpecifierContext>();
}

CPP14Parser::AttributeSpecifierContext* CPP14Parser::AttributeSpecifierSeqContext::attributeSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::AttributeSpecifierContext>(i);
}


size_t CPP14Parser::AttributeSpecifierSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeSpecifierSeq;
}


std::any CPP14Parser::AttributeSpecifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeSpecifierSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::attributeSpecifierSeq() {
  AttributeSpecifierSeqContext *_localctx = _tracker.createInstance<AttributeSpecifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 204, CPP14Parser::RuleAttributeSpecifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1310); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1309);
              attributeSpecifier();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1312); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeSpecifierContext ------------------------------------------------------------------

CPP14Parser::AttributeSpecifierContext::AttributeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CPP14Parser::AttributeSpecifierContext::LeftBracket() {
  return getTokens(CPP14Parser::LeftBracket);
}

tree::TerminalNode* CPP14Parser::AttributeSpecifierContext::LeftBracket(size_t i) {
  return getToken(CPP14Parser::LeftBracket, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::AttributeSpecifierContext::RightBracket() {
  return getTokens(CPP14Parser::RightBracket);
}

tree::TerminalNode* CPP14Parser::AttributeSpecifierContext::RightBracket(size_t i) {
  return getToken(CPP14Parser::RightBracket, i);
}

CPP14Parser::AttributeListContext* CPP14Parser::AttributeSpecifierContext::attributeList() {
  return getRuleContext<CPP14Parser::AttributeListContext>(0);
}

CPP14Parser::AlignmentspecifierContext* CPP14Parser::AttributeSpecifierContext::alignmentspecifier() {
  return getRuleContext<CPP14Parser::AlignmentspecifierContext>(0);
}


size_t CPP14Parser::AttributeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeSpecifier;
}


std::any CPP14Parser::AttributeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeSpecifierContext* CPP14Parser::attributeSpecifier() {
  AttributeSpecifierContext *_localctx = _tracker.createInstance<AttributeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 206, CPP14Parser::RuleAttributeSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1322);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 1);
        setState(1314);
        match(CPP14Parser::LeftBracket);
        setState(1315);
        match(CPP14Parser::LeftBracket);
        setState(1317);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Identifier) {
          setState(1316);
          attributeList();
        }
        setState(1319);
        match(CPP14Parser::RightBracket);
        setState(1320);
        match(CPP14Parser::RightBracket);
        break;
      }

      case CPP14Parser::Alignas: {
        enterOuterAlt(_localctx, 2);
        setState(1321);
        alignmentspecifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlignmentspecifierContext ------------------------------------------------------------------

CPP14Parser::AlignmentspecifierContext::AlignmentspecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::Alignas() {
  return getToken(CPP14Parser::Alignas, 0);
}

tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::AlignmentspecifierContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::AlignmentspecifierContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::AlignmentspecifierContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}


size_t CPP14Parser::AlignmentspecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleAlignmentspecifier;
}


std::any CPP14Parser::AlignmentspecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAlignmentspecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AlignmentspecifierContext* CPP14Parser::alignmentspecifier() {
  AlignmentspecifierContext *_localctx = _tracker.createInstance<AlignmentspecifierContext>(_ctx, getState());
  enterRule(_localctx, 208, CPP14Parser::RuleAlignmentspecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1324);
    match(CPP14Parser::Alignas);
    setState(1325);
    match(CPP14Parser::LeftParen);
    setState(1328);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx)) {
    case 1: {
      setState(1326);
      theTypeId();
      break;
    }

    case 2: {
      setState(1327);
      constantExpression();
      break;
    }

    default:
      break;
    }
    setState(1331);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1330);
      match(CPP14Parser::Ellipsis);
    }
    setState(1333);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeListContext ------------------------------------------------------------------

CPP14Parser::AttributeListContext::AttributeListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::AttributeContext *> CPP14Parser::AttributeListContext::attribute() {
  return getRuleContexts<CPP14Parser::AttributeContext>();
}

CPP14Parser::AttributeContext* CPP14Parser::AttributeListContext::attribute(size_t i) {
  return getRuleContext<CPP14Parser::AttributeContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::AttributeListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::AttributeListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}

tree::TerminalNode* CPP14Parser::AttributeListContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}


size_t CPP14Parser::AttributeListContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeList;
}


std::any CPP14Parser::AttributeListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeListContext* CPP14Parser::attributeList() {
  AttributeListContext *_localctx = _tracker.createInstance<AttributeListContext>(_ctx, getState());
  enterRule(_localctx, 210, CPP14Parser::RuleAttributeList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1335);
    attribute();
    setState(1340);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1336);
      match(CPP14Parser::Comma);
      setState(1337);
      attribute();
      setState(1342);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1344);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1343);
      match(CPP14Parser::Ellipsis);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeContext ------------------------------------------------------------------

CPP14Parser::AttributeContext::AttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AttributeContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::AttributeNamespaceContext* CPP14Parser::AttributeContext::attributeNamespace() {
  return getRuleContext<CPP14Parser::AttributeNamespaceContext>(0);
}

tree::TerminalNode* CPP14Parser::AttributeContext::Doublecolon() {
  return getToken(CPP14Parser::Doublecolon, 0);
}

CPP14Parser::AttributeArgumentClauseContext* CPP14Parser::AttributeContext::attributeArgumentClause() {
  return getRuleContext<CPP14Parser::AttributeArgumentClauseContext>(0);
}


size_t CPP14Parser::AttributeContext::getRuleIndex() const {
  return CPP14Parser::RuleAttribute;
}


std::any CPP14Parser::AttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttribute(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeContext* CPP14Parser::attribute() {
  AttributeContext *_localctx = _tracker.createInstance<AttributeContext>(_ctx, getState());
  enterRule(_localctx, 212, CPP14Parser::RuleAttribute);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1349);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx)) {
    case 1: {
      setState(1346);
      attributeNamespace();
      setState(1347);
      match(CPP14Parser::Doublecolon);
      break;
    }

    default:
      break;
    }
    setState(1351);
    match(CPP14Parser::Identifier);
    setState(1353);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::LeftParen) {
      setState(1352);
      attributeArgumentClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeNamespaceContext ------------------------------------------------------------------

CPP14Parser::AttributeNamespaceContext::AttributeNamespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AttributeNamespaceContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::AttributeNamespaceContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeNamespace;
}


std::any CPP14Parser::AttributeNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeNamespace(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeNamespaceContext* CPP14Parser::attributeNamespace() {
  AttributeNamespaceContext *_localctx = _tracker.createInstance<AttributeNamespaceContext>(_ctx, getState());
  enterRule(_localctx, 214, CPP14Parser::RuleAttributeNamespace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1355);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AttributeArgumentClauseContext ------------------------------------------------------------------

CPP14Parser::AttributeArgumentClauseContext::AttributeArgumentClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AttributeArgumentClauseContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::AttributeArgumentClauseContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::BalancedTokenSeqContext* CPP14Parser::AttributeArgumentClauseContext::balancedTokenSeq() {
  return getRuleContext<CPP14Parser::BalancedTokenSeqContext>(0);
}


size_t CPP14Parser::AttributeArgumentClauseContext::getRuleIndex() const {
  return CPP14Parser::RuleAttributeArgumentClause;
}


std::any CPP14Parser::AttributeArgumentClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAttributeArgumentClause(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AttributeArgumentClauseContext* CPP14Parser::attributeArgumentClause() {
  AttributeArgumentClauseContext *_localctx = _tracker.createInstance<AttributeArgumentClauseContext>(_ctx, getState());
  enterRule(_localctx, 216, CPP14Parser::RuleAttributeArgumentClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1357);
    match(CPP14Parser::LeftParen);
    setState(1359);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -2) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -88080385) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 524287) != 0) {
      setState(1358);
      balancedTokenSeq();
    }
    setState(1361);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BalancedTokenSeqContext ------------------------------------------------------------------

CPP14Parser::BalancedTokenSeqContext::BalancedTokenSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::BalancedtokenContext *> CPP14Parser::BalancedTokenSeqContext::balancedtoken() {
  return getRuleContexts<CPP14Parser::BalancedtokenContext>();
}

CPP14Parser::BalancedtokenContext* CPP14Parser::BalancedTokenSeqContext::balancedtoken(size_t i) {
  return getRuleContext<CPP14Parser::BalancedtokenContext>(i);
}


size_t CPP14Parser::BalancedTokenSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleBalancedTokenSeq;
}


std::any CPP14Parser::BalancedTokenSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBalancedTokenSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BalancedTokenSeqContext* CPP14Parser::balancedTokenSeq() {
  BalancedTokenSeqContext *_localctx = _tracker.createInstance<BalancedTokenSeqContext>(_ctx, getState());
  enterRule(_localctx, 218, CPP14Parser::RuleBalancedTokenSeq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1364); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1363);
      balancedtoken();
      setState(1366); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -2) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -88080385) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 524287) != 0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BalancedtokenContext ------------------------------------------------------------------

CPP14Parser::BalancedtokenContext::BalancedtokenContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::LeftParen() {
  return getTokens(CPP14Parser::LeftParen);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftParen(size_t i) {
  return getToken(CPP14Parser::LeftParen, i);
}

CPP14Parser::BalancedTokenSeqContext* CPP14Parser::BalancedtokenContext::balancedTokenSeq() {
  return getRuleContext<CPP14Parser::BalancedTokenSeqContext>(0);
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::RightParen() {
  return getTokens(CPP14Parser::RightParen);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightParen(size_t i) {
  return getToken(CPP14Parser::RightParen, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::LeftBracket() {
  return getTokens(CPP14Parser::LeftBracket);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftBracket(size_t i) {
  return getToken(CPP14Parser::LeftBracket, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::RightBracket() {
  return getTokens(CPP14Parser::RightBracket);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightBracket(size_t i) {
  return getToken(CPP14Parser::RightBracket, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::LeftBrace() {
  return getTokens(CPP14Parser::LeftBrace);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::LeftBrace(size_t i) {
  return getToken(CPP14Parser::LeftBrace, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BalancedtokenContext::RightBrace() {
  return getTokens(CPP14Parser::RightBrace);
}

tree::TerminalNode* CPP14Parser::BalancedtokenContext::RightBrace(size_t i) {
  return getToken(CPP14Parser::RightBrace, i);
}


size_t CPP14Parser::BalancedtokenContext::getRuleIndex() const {
  return CPP14Parser::RuleBalancedtoken;
}


std::any CPP14Parser::BalancedtokenContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBalancedtoken(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BalancedtokenContext* CPP14Parser::balancedtoken() {
  BalancedtokenContext *_localctx = _tracker.createInstance<BalancedtokenContext>(_ctx, getState());
  enterRule(_localctx, 220, CPP14Parser::RuleBalancedtoken);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1385);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftParen: {
        enterOuterAlt(_localctx, 1);
        setState(1368);
        match(CPP14Parser::LeftParen);
        setState(1369);
        balancedTokenSeq();
        setState(1370);
        match(CPP14Parser::RightParen);
        break;
      }

      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 2);
        setState(1372);
        match(CPP14Parser::LeftBracket);
        setState(1373);
        balancedTokenSeq();
        setState(1374);
        match(CPP14Parser::RightBracket);
        break;
      }

      case CPP14Parser::LeftBrace: {
        enterOuterAlt(_localctx, 3);
        setState(1376);
        match(CPP14Parser::LeftBrace);
        setState(1377);
        balancedTokenSeq();
        setState(1378);
        match(CPP14Parser::RightBrace);
        break;
      }

      case CPP14Parser::IntegerLiteral:
      case CPP14Parser::CharacterLiteral:
      case CPP14Parser::FloatingLiteral:
      case CPP14Parser::StringLiteral:
      case CPP14Parser::BooleanLiteral:
      case CPP14Parser::PointerLiteral:
      case CPP14Parser::UserDefinedLiteral:
      case CPP14Parser::MultiLineMacro:
      case CPP14Parser::Directive:
      case CPP14Parser::Alignas:
      case CPP14Parser::Alignof:
      case CPP14Parser::Asm:
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Break:
      case CPP14Parser::Case:
      case CPP14Parser::Catch:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Constexpr:
      case CPP14Parser::Const_cast:
      case CPP14Parser::Continue:
      case CPP14Parser::Decltype:
      case CPP14Parser::Default:
      case CPP14Parser::Delete:
      case CPP14Parser::Do:
      case CPP14Parser::Double:
      case CPP14Parser::Dynamic_cast:
      case CPP14Parser::Else:
      case CPP14Parser::Enum:
      case CPP14Parser::Explicit:
      case CPP14Parser::Export:
      case CPP14Parser::Extern:
      case CPP14Parser::False_:
      case CPP14Parser::Final:
      case CPP14Parser::Float:
      case CPP14Parser::For:
      case CPP14Parser::Friend:
      case CPP14Parser::Goto:
      case CPP14Parser::If:
      case CPP14Parser::Inline:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Mutable:
      case CPP14Parser::Namespace:
      case CPP14Parser::New:
      case CPP14Parser::Noexcept:
      case CPP14Parser::Nullptr:
      case CPP14Parser::Operator:
      case CPP14Parser::Override:
      case CPP14Parser::Private:
      case CPP14Parser::Protected:
      case CPP14Parser::Public:
      case CPP14Parser::Register:
      case CPP14Parser::Reinterpret_cast:
      case CPP14Parser::Return:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Sizeof:
      case CPP14Parser::Static:
      case CPP14Parser::Static_assert:
      case CPP14Parser::Static_cast:
      case CPP14Parser::Struct:
      case CPP14Parser::Switch:
      case CPP14Parser::Template:
      case CPP14Parser::This:
      case CPP14Parser::Thread_local:
      case CPP14Parser::Throw:
      case CPP14Parser::True_:
      case CPP14Parser::Try:
      case CPP14Parser::Typedef:
      case CPP14Parser::Typeid_:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Using:
      case CPP14Parser::Virtual:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::While:
      case CPP14Parser::Plus:
      case CPP14Parser::Minus:
      case CPP14Parser::Star:
      case CPP14Parser::Div:
      case CPP14Parser::Mod:
      case CPP14Parser::Caret:
      case CPP14Parser::And:
      case CPP14Parser::Or:
      case CPP14Parser::Tilde:
      case CPP14Parser::Not:
      case CPP14Parser::Assign:
      case CPP14Parser::Less:
      case CPP14Parser::Greater:
      case CPP14Parser::PlusAssign:
      case CPP14Parser::MinusAssign:
      case CPP14Parser::StarAssign:
      case CPP14Parser::DivAssign:
      case CPP14Parser::ModAssign:
      case CPP14Parser::XorAssign:
      case CPP14Parser::AndAssign:
      case CPP14Parser::OrAssign:
      case CPP14Parser::LeftShiftAssign:
      case CPP14Parser::RightShiftAssign:
      case CPP14Parser::Equal:
      case CPP14Parser::NotEqual:
      case CPP14Parser::LessEqual:
      case CPP14Parser::GreaterEqual:
      case CPP14Parser::AndAnd:
      case CPP14Parser::OrOr:
      case CPP14Parser::PlusPlus:
      case CPP14Parser::MinusMinus:
      case CPP14Parser::Comma:
      case CPP14Parser::ArrowStar:
      case CPP14Parser::Arrow:
      case CPP14Parser::Question:
      case CPP14Parser::Colon:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Semi:
      case CPP14Parser::Dot:
      case CPP14Parser::DotStar:
      case CPP14Parser::Ellipsis:
      case CPP14Parser::Identifier:
      case CPP14Parser::DecimalLiteral:
      case CPP14Parser::OctalLiteral:
      case CPP14Parser::HexadecimalLiteral:
      case CPP14Parser::BinaryLiteral:
      case CPP14Parser::Integersuffix:
      case CPP14Parser::UserDefinedIntegerLiteral:
      case CPP14Parser::UserDefinedFloatingLiteral:
      case CPP14Parser::UserDefinedStringLiteral:
      case CPP14Parser::UserDefinedCharacterLiteral:
      case CPP14Parser::Whitespace:
      case CPP14Parser::Newline:
      case CPP14Parser::BlockComment:
      case CPP14Parser::LineComment:
      case CPP14Parser::ENTER: {
        enterOuterAlt(_localctx, 4);
        setState(1381); 
        _errHandler->sync(this);
        alt = 1;
        do {
          switch (alt) {
            case 1: {
                  setState(1380);
                  _la = _input->LA(1);
                  if (_la == 0 || _la == Token::EOF || ((((_la - 85) & ~ 0x3fULL) == 0) &&
                    ((1ULL << (_la - 85)) & 63) != 0)) {
                  _errHandler->recoverInline(this);
                  }
                  else {
                    _errHandler->reportMatch(this);
                    consume();
                  }
                  break;
                }

          default:
            throw NoViableAltException(this);
          }
          setState(1383); 
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 164, _ctx);
        } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitDeclaratorListContext ------------------------------------------------------------------

CPP14Parser::InitDeclaratorListContext::InitDeclaratorListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::InitDeclaratorContext *> CPP14Parser::InitDeclaratorListContext::initDeclarator() {
  return getRuleContexts<CPP14Parser::InitDeclaratorContext>();
}

CPP14Parser::InitDeclaratorContext* CPP14Parser::InitDeclaratorListContext::initDeclarator(size_t i) {
  return getRuleContext<CPP14Parser::InitDeclaratorContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::InitDeclaratorListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::InitDeclaratorListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::InitDeclaratorListContext::getRuleIndex() const {
  return CPP14Parser::RuleInitDeclaratorList;
}


std::any CPP14Parser::InitDeclaratorListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitDeclaratorList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitDeclaratorListContext* CPP14Parser::initDeclaratorList() {
  InitDeclaratorListContext *_localctx = _tracker.createInstance<InitDeclaratorListContext>(_ctx, getState());
  enterRule(_localctx, 222, CPP14Parser::RuleInitDeclaratorList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1387);
    initDeclarator();
    setState(1392);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1388);
      match(CPP14Parser::Comma);
      setState(1389);
      initDeclarator();
      setState(1394);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitDeclaratorContext ------------------------------------------------------------------

CPP14Parser::InitDeclaratorContext::InitDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclaratorContext* CPP14Parser::InitDeclaratorContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

CPP14Parser::InitializerContext* CPP14Parser::InitDeclaratorContext::initializer() {
  return getRuleContext<CPP14Parser::InitializerContext>(0);
}


size_t CPP14Parser::InitDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleInitDeclarator;
}


std::any CPP14Parser::InitDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitDeclaratorContext* CPP14Parser::initDeclarator() {
  InitDeclaratorContext *_localctx = _tracker.createInstance<InitDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 224, CPP14Parser::RuleInitDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1395);
    declarator();
    setState(1397);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 85) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 85)) & 65553) != 0) {
      setState(1396);
      initializer();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclaratorContext ------------------------------------------------------------------

CPP14Parser::DeclaratorContext::DeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PointerDeclaratorContext* CPP14Parser::DeclaratorContext::pointerDeclarator() {
  return getRuleContext<CPP14Parser::PointerDeclaratorContext>(0);
}

CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::DeclaratorContext::noPointerDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerDeclaratorContext>(0);
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::DeclaratorContext::parametersAndQualifiers() {
  return getRuleContext<CPP14Parser::ParametersAndQualifiersContext>(0);
}

CPP14Parser::TrailingReturnTypeContext* CPP14Parser::DeclaratorContext::trailingReturnType() {
  return getRuleContext<CPP14Parser::TrailingReturnTypeContext>(0);
}


size_t CPP14Parser::DeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclarator;
}


std::any CPP14Parser::DeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclaratorContext* CPP14Parser::declarator() {
  DeclaratorContext *_localctx = _tracker.createInstance<DeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 226, CPP14Parser::RuleDeclarator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1404);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1399);
      pointerDeclarator();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1400);
      noPointerDeclarator(0);
      setState(1401);
      parametersAndQualifiers();
      setState(1402);
      trailingReturnType();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PointerDeclaratorContext ------------------------------------------------------------------

CPP14Parser::PointerDeclaratorContext::PointerDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::PointerDeclaratorContext::noPointerDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerDeclaratorContext>(0);
}

std::vector<CPP14Parser::PointerOperatorContext *> CPP14Parser::PointerDeclaratorContext::pointerOperator() {
  return getRuleContexts<CPP14Parser::PointerOperatorContext>();
}

CPP14Parser::PointerOperatorContext* CPP14Parser::PointerDeclaratorContext::pointerOperator(size_t i) {
  return getRuleContext<CPP14Parser::PointerOperatorContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::PointerDeclaratorContext::Const() {
  return getTokens(CPP14Parser::Const);
}

tree::TerminalNode* CPP14Parser::PointerDeclaratorContext::Const(size_t i) {
  return getToken(CPP14Parser::Const, i);
}


size_t CPP14Parser::PointerDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RulePointerDeclarator;
}


std::any CPP14Parser::PointerDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPointerDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PointerDeclaratorContext* CPP14Parser::pointerDeclarator() {
  PointerDeclaratorContext *_localctx = _tracker.createInstance<PointerDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 228, CPP14Parser::RulePointerDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1412);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1406);
        pointerOperator();
        setState(1408);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Const) {
          setState(1407);
          match(CPP14Parser::Const);
        } 
      }
      setState(1414);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx);
    }
    setState(1415);
    noPointerDeclarator(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoPointerDeclaratorContext ------------------------------------------------------------------

CPP14Parser::NoPointerDeclaratorContext::NoPointerDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclaratoridContext* CPP14Parser::NoPointerDeclaratorContext::declaratorid() {
  return getRuleContext<CPP14Parser::DeclaratoridContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::PointerDeclaratorContext* CPP14Parser::NoPointerDeclaratorContext::pointerDeclarator() {
  return getRuleContext<CPP14Parser::PointerDeclaratorContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::NoPointerDeclaratorContext::noPointerDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerDeclaratorContext>(0);
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerDeclaratorContext::parametersAndQualifiers() {
  return getRuleContext<CPP14Parser::ParametersAndQualifiersContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::NoPointerDeclaratorContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerDeclaratorContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}


size_t CPP14Parser::NoPointerDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleNoPointerDeclarator;
}


std::any CPP14Parser::NoPointerDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoPointerDeclarator(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::noPointerDeclarator() {
   return noPointerDeclarator(0);
}

CPP14Parser::NoPointerDeclaratorContext* CPP14Parser::noPointerDeclarator(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::NoPointerDeclaratorContext *_localctx = _tracker.createInstance<NoPointerDeclaratorContext>(_ctx, parentState);
  CPP14Parser::NoPointerDeclaratorContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 230;
  enterRecursionRule(_localctx, 230, CPP14Parser::RuleNoPointerDeclarator, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1426);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Decltype:
      case CPP14Parser::Operator:
      case CPP14Parser::Tilde:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Ellipsis:
      case CPP14Parser::Identifier: {
        setState(1418);
        declaratorid();
        setState(1420);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx)) {
        case 1: {
          setState(1419);
          attributeSpecifierSeq();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::LeftParen: {
        setState(1422);
        match(CPP14Parser::LeftParen);
        setState(1423);
        pointerDeclarator();
        setState(1424);
        match(CPP14Parser::RightParen);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(1442);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 176, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<NoPointerDeclaratorContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleNoPointerDeclarator);
        setState(1428);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(1438);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case CPP14Parser::LeftParen: {
            setState(1429);
            parametersAndQualifiers();
            break;
          }

          case CPP14Parser::LeftBracket: {
            setState(1430);
            match(CPP14Parser::LeftBracket);
            setState(1432);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (((_la & ~ 0x3fULL) == 0) &&
              ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
              ((1ULL << (_la - 65)) & 4719772474384133137) != 0 || _la == CPP14Parser::Identifier) {
              setState(1431);
              constantExpression();
            }
            setState(1434);
            match(CPP14Parser::RightBracket);
            setState(1436);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 174, _ctx)) {
            case 1: {
              setState(1435);
              attributeSpecifierSeq();
              break;
            }

            default:
              break;
            }
            break;
          }

        default:
          throw NoViableAltException(this);
        } 
      }
      setState(1444);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 176, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- ParametersAndQualifiersContext ------------------------------------------------------------------

CPP14Parser::ParametersAndQualifiersContext::ParametersAndQualifiersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ParametersAndQualifiersContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::ParametersAndQualifiersContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::ParametersAndQualifiersContext::parameterDeclarationClause() {
  return getRuleContext<CPP14Parser::ParameterDeclarationClauseContext>(0);
}

CPP14Parser::CvqualifierseqContext* CPP14Parser::ParametersAndQualifiersContext::cvqualifierseq() {
  return getRuleContext<CPP14Parser::CvqualifierseqContext>(0);
}

CPP14Parser::RefqualifierContext* CPP14Parser::ParametersAndQualifiersContext::refqualifier() {
  return getRuleContext<CPP14Parser::RefqualifierContext>(0);
}

CPP14Parser::ExceptionSpecificationContext* CPP14Parser::ParametersAndQualifiersContext::exceptionSpecification() {
  return getRuleContext<CPP14Parser::ExceptionSpecificationContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ParametersAndQualifiersContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::ParametersAndQualifiersContext::getRuleIndex() const {
  return CPP14Parser::RuleParametersAndQualifiers;
}


std::any CPP14Parser::ParametersAndQualifiersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitParametersAndQualifiers(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::parametersAndQualifiers() {
  ParametersAndQualifiersContext *_localctx = _tracker.createInstance<ParametersAndQualifiersContext>(_ctx, getState());
  enterRule(_localctx, 232, CPP14Parser::RuleParametersAndQualifiers);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1445);
    match(CPP14Parser::LeftParen);
    setState(1447);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1237504995584196377) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 297237575406461917) != 0) {
      setState(1446);
      parameterDeclarationClause();
    }
    setState(1449);
    match(CPP14Parser::RightParen);
    setState(1451);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 178, _ctx)) {
    case 1: {
      setState(1450);
      cvqualifierseq();
      break;
    }

    default:
      break;
    }
    setState(1454);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx)) {
    case 1: {
      setState(1453);
      refqualifier();
      break;
    }

    default:
      break;
    }
    setState(1457);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
    case 1: {
      setState(1456);
      exceptionSpecification();
      break;
    }

    default:
      break;
    }
    setState(1460);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
    case 1: {
      setState(1459);
      attributeSpecifierSeq();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TrailingReturnTypeContext ------------------------------------------------------------------

CPP14Parser::TrailingReturnTypeContext::TrailingReturnTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TrailingReturnTypeContext::Arrow() {
  return getToken(CPP14Parser::Arrow, 0);
}

CPP14Parser::TrailingTypeSpecifierSeqContext* CPP14Parser::TrailingReturnTypeContext::trailingTypeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TrailingTypeSpecifierSeqContext>(0);
}

CPP14Parser::AbstractDeclaratorContext* CPP14Parser::TrailingReturnTypeContext::abstractDeclarator() {
  return getRuleContext<CPP14Parser::AbstractDeclaratorContext>(0);
}


size_t CPP14Parser::TrailingReturnTypeContext::getRuleIndex() const {
  return CPP14Parser::RuleTrailingReturnType;
}


std::any CPP14Parser::TrailingReturnTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTrailingReturnType(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TrailingReturnTypeContext* CPP14Parser::trailingReturnType() {
  TrailingReturnTypeContext *_localctx = _tracker.createInstance<TrailingReturnTypeContext>(_ctx, getState());
  enterRule(_localctx, 234, CPP14Parser::RuleTrailingReturnType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1462);
    match(CPP14Parser::Arrow);
    setState(1463);
    trailingTypeSpecifierSeq();
    setState(1465);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 182, _ctx)) {
    case 1: {
      setState(1464);
      abstractDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PointerOperatorContext ------------------------------------------------------------------

CPP14Parser::PointerOperatorContext::PointerOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::PointerOperatorContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::PointerOperatorContext::AndAnd() {
  return getToken(CPP14Parser::AndAnd, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::PointerOperatorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::PointerOperatorContext::Star() {
  return getToken(CPP14Parser::Star, 0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::PointerOperatorContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

CPP14Parser::CvqualifierseqContext* CPP14Parser::PointerOperatorContext::cvqualifierseq() {
  return getRuleContext<CPP14Parser::CvqualifierseqContext>(0);
}


size_t CPP14Parser::PointerOperatorContext::getRuleIndex() const {
  return CPP14Parser::RulePointerOperator;
}


std::any CPP14Parser::PointerOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPointerOperator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PointerOperatorContext* CPP14Parser::pointerOperator() {
  PointerOperatorContext *_localctx = _tracker.createInstance<PointerOperatorContext>(_ctx, getState());
  enterRule(_localctx, 236, CPP14Parser::RulePointerOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1481);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::And:
      case CPP14Parser::AndAnd: {
        enterOuterAlt(_localctx, 1);
        setState(1467);
        _la = _input->LA(1);
        if (!(_la == CPP14Parser::And

        || _la == CPP14Parser::AndAnd)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1469);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 183, _ctx)) {
        case 1: {
          setState(1468);
          attributeSpecifierSeq();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::Decltype:
      case CPP14Parser::Star:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 2);
        setState(1472);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon

        || _la == CPP14Parser::Identifier) {
          setState(1471);
          nestedNameSpecifier(0);
        }
        setState(1474);
        match(CPP14Parser::Star);
        setState(1476);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 185, _ctx)) {
        case 1: {
          setState(1475);
          attributeSpecifierSeq();
          break;
        }

        default:
          break;
        }
        setState(1479);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 186, _ctx)) {
        case 1: {
          setState(1478);
          cvqualifierseq();
          break;
        }

        default:
          break;
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CvqualifierseqContext ------------------------------------------------------------------

CPP14Parser::CvqualifierseqContext::CvqualifierseqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::CvQualifierContext *> CPP14Parser::CvqualifierseqContext::cvQualifier() {
  return getRuleContexts<CPP14Parser::CvQualifierContext>();
}

CPP14Parser::CvQualifierContext* CPP14Parser::CvqualifierseqContext::cvQualifier(size_t i) {
  return getRuleContext<CPP14Parser::CvQualifierContext>(i);
}


size_t CPP14Parser::CvqualifierseqContext::getRuleIndex() const {
  return CPP14Parser::RuleCvqualifierseq;
}


std::any CPP14Parser::CvqualifierseqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCvqualifierseq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CvqualifierseqContext* CPP14Parser::cvqualifierseq() {
  CvqualifierseqContext *_localctx = _tracker.createInstance<CvqualifierseqContext>(_ctx, getState());
  enterRule(_localctx, 238, CPP14Parser::RuleCvqualifierseq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1484); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1483);
              cvQualifier();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1486); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 188, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CvQualifierContext ------------------------------------------------------------------

CPP14Parser::CvQualifierContext::CvQualifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::CvQualifierContext::Const() {
  return getToken(CPP14Parser::Const, 0);
}

tree::TerminalNode* CPP14Parser::CvQualifierContext::Volatile() {
  return getToken(CPP14Parser::Volatile, 0);
}


size_t CPP14Parser::CvQualifierContext::getRuleIndex() const {
  return CPP14Parser::RuleCvQualifier;
}


std::any CPP14Parser::CvQualifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitCvQualifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::CvQualifierContext* CPP14Parser::cvQualifier() {
  CvQualifierContext *_localctx = _tracker.createInstance<CvQualifierContext>(_ctx, getState());
  enterRule(_localctx, 240, CPP14Parser::RuleCvQualifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1488);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::Const

    || _la == CPP14Parser::Volatile)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RefqualifierContext ------------------------------------------------------------------

CPP14Parser::RefqualifierContext::RefqualifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::RefqualifierContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::RefqualifierContext::AndAnd() {
  return getToken(CPP14Parser::AndAnd, 0);
}


size_t CPP14Parser::RefqualifierContext::getRuleIndex() const {
  return CPP14Parser::RuleRefqualifier;
}


std::any CPP14Parser::RefqualifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitRefqualifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::RefqualifierContext* CPP14Parser::refqualifier() {
  RefqualifierContext *_localctx = _tracker.createInstance<RefqualifierContext>(_ctx, getState());
  enterRule(_localctx, 242, CPP14Parser::RuleRefqualifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1490);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::And

    || _la == CPP14Parser::AndAnd)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeclaratoridContext ------------------------------------------------------------------

CPP14Parser::DeclaratoridContext::DeclaratoridContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::IdExpressionContext* CPP14Parser::DeclaratoridContext::idExpression() {
  return getRuleContext<CPP14Parser::IdExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::DeclaratoridContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}


size_t CPP14Parser::DeclaratoridContext::getRuleIndex() const {
  return CPP14Parser::RuleDeclaratorid;
}


std::any CPP14Parser::DeclaratoridContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDeclaratorid(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DeclaratoridContext* CPP14Parser::declaratorid() {
  DeclaratoridContext *_localctx = _tracker.createInstance<DeclaratoridContext>(_ctx, getState());
  enterRule(_localctx, 244, CPP14Parser::RuleDeclaratorid);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1493);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1492);
      match(CPP14Parser::Ellipsis);
    }
    setState(1495);
    idExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TheTypeIdContext ------------------------------------------------------------------

CPP14Parser::TheTypeIdContext::TheTypeIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::TheTypeIdContext::typeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TypeSpecifierSeqContext>(0);
}

CPP14Parser::AbstractDeclaratorContext* CPP14Parser::TheTypeIdContext::abstractDeclarator() {
  return getRuleContext<CPP14Parser::AbstractDeclaratorContext>(0);
}


size_t CPP14Parser::TheTypeIdContext::getRuleIndex() const {
  return CPP14Parser::RuleTheTypeId;
}


std::any CPP14Parser::TheTypeIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTheTypeId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::theTypeId() {
  TheTypeIdContext *_localctx = _tracker.createInstance<TheTypeIdContext>(_ctx, getState());
  enterRule(_localctx, 246, CPP14Parser::RuleTheTypeId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1497);
    typeSpecifierSeq();
    setState(1499);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 190, _ctx)) {
    case 1: {
      setState(1498);
      abstractDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AbstractDeclaratorContext ------------------------------------------------------------------

CPP14Parser::AbstractDeclaratorContext::AbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::pointerAbstractDeclarator() {
  return getRuleContext<CPP14Parser::PointerAbstractDeclaratorContext>(0);
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::AbstractDeclaratorContext::parametersAndQualifiers() {
  return getRuleContext<CPP14Parser::ParametersAndQualifiersContext>(0);
}

CPP14Parser::TrailingReturnTypeContext* CPP14Parser::AbstractDeclaratorContext::trailingReturnType() {
  return getRuleContext<CPP14Parser::TrailingReturnTypeContext>(0);
}

CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::noPointerAbstractDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerAbstractDeclaratorContext>(0);
}

CPP14Parser::AbstractPackDeclaratorContext* CPP14Parser::AbstractDeclaratorContext::abstractPackDeclarator() {
  return getRuleContext<CPP14Parser::AbstractPackDeclaratorContext>(0);
}


size_t CPP14Parser::AbstractDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleAbstractDeclarator;
}


std::any CPP14Parser::AbstractDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAbstractDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AbstractDeclaratorContext* CPP14Parser::abstractDeclarator() {
  AbstractDeclaratorContext *_localctx = _tracker.createInstance<AbstractDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 248, CPP14Parser::RuleAbstractDeclarator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1509);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1501);
      pointerAbstractDeclarator();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1503);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 191, _ctx)) {
      case 1: {
        setState(1502);
        noPointerAbstractDeclarator(0);
        break;
      }

      default:
        break;
      }
      setState(1505);
      parametersAndQualifiers();
      setState(1506);
      trailingReturnType();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1508);
      abstractPackDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PointerAbstractDeclaratorContext ------------------------------------------------------------------

CPP14Parser::PointerAbstractDeclaratorContext::PointerAbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::PointerAbstractDeclaratorContext::noPointerAbstractDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerAbstractDeclaratorContext>(0);
}

std::vector<CPP14Parser::PointerOperatorContext *> CPP14Parser::PointerAbstractDeclaratorContext::pointerOperator() {
  return getRuleContexts<CPP14Parser::PointerOperatorContext>();
}

CPP14Parser::PointerOperatorContext* CPP14Parser::PointerAbstractDeclaratorContext::pointerOperator(size_t i) {
  return getRuleContext<CPP14Parser::PointerOperatorContext>(i);
}


size_t CPP14Parser::PointerAbstractDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RulePointerAbstractDeclarator;
}


std::any CPP14Parser::PointerAbstractDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPointerAbstractDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::pointerAbstractDeclarator() {
  PointerAbstractDeclaratorContext *_localctx = _tracker.createInstance<PointerAbstractDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 250, CPP14Parser::RulePointerAbstractDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1520);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftParen:
      case CPP14Parser::LeftBracket: {
        enterOuterAlt(_localctx, 1);
        setState(1511);
        noPointerAbstractDeclarator(0);
        break;
      }

      case CPP14Parser::Decltype:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::AndAnd:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 2);
        setState(1513); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(1512);
          pointerOperator();
          setState(1515); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == CPP14Parser::Decltype || (((_la - 93) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 93)) & 566969237521) != 0);
        setState(1518);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 194, _ctx)) {
        case 1: {
          setState(1517);
          noPointerAbstractDeclarator(0);
          break;
        }

        default:
          break;
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoPointerAbstractDeclaratorContext ------------------------------------------------------------------

CPP14Parser::NoPointerAbstractDeclaratorContext::NoPointerAbstractDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerAbstractDeclaratorContext::parametersAndQualifiers() {
  return getRuleContext<CPP14Parser::ParametersAndQualifiersContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerAbstractDeclaratorContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerAbstractDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::PointerAbstractDeclaratorContext* CPP14Parser::NoPointerAbstractDeclaratorContext::pointerAbstractDeclarator() {
  return getRuleContext<CPP14Parser::PointerAbstractDeclaratorContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractDeclaratorContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

std::vector<CPP14Parser::NoPointerAbstractDeclaratorContext *> CPP14Parser::NoPointerAbstractDeclaratorContext::noPointerAbstractDeclarator() {
  return getRuleContexts<CPP14Parser::NoPointerAbstractDeclaratorContext>();
}

CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::NoPointerAbstractDeclaratorContext::noPointerAbstractDeclarator(size_t i) {
  return getRuleContext<CPP14Parser::NoPointerAbstractDeclaratorContext>(i);
}


size_t CPP14Parser::NoPointerAbstractDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleNoPointerAbstractDeclarator;
}


std::any CPP14Parser::NoPointerAbstractDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoPointerAbstractDeclarator(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::noPointerAbstractDeclarator() {
   return noPointerAbstractDeclarator(0);
}

CPP14Parser::NoPointerAbstractDeclaratorContext* CPP14Parser::noPointerAbstractDeclarator(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::NoPointerAbstractDeclaratorContext *_localctx = _tracker.createInstance<NoPointerAbstractDeclaratorContext>(_ctx, parentState);
  CPP14Parser::NoPointerAbstractDeclaratorContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 252;
  enterRecursionRule(_localctx, 252, CPP14Parser::RuleNoPointerAbstractDeclarator, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1536);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 198, _ctx)) {
    case 1: {
      setState(1523);
      parametersAndQualifiers();
      break;
    }

    case 2: {
      setState(1524);
      match(CPP14Parser::LeftBracket);
      setState(1526);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 65)) & 4719772474384133137) != 0 || _la == CPP14Parser::Identifier) {
        setState(1525);
        constantExpression();
      }
      setState(1528);
      match(CPP14Parser::RightBracket);
      setState(1530);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 197, _ctx)) {
      case 1: {
        setState(1529);
        attributeSpecifierSeq();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      setState(1532);
      match(CPP14Parser::LeftParen);
      setState(1533);
      pointerAbstractDeclarator();
      setState(1534);
      match(CPP14Parser::RightParen);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(1553);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 202, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<NoPointerAbstractDeclaratorContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleNoPointerAbstractDeclarator);
        setState(1538);

        if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
        setState(1549);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx)) {
        case 1: {
          setState(1539);
          parametersAndQualifiers();
          break;
        }

        case 2: {
          setState(1540);
          noPointerAbstractDeclarator(0);
          setState(1541);
          match(CPP14Parser::LeftBracket);
          setState(1543);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 65)) & 4719772474384133137) != 0 || _la == CPP14Parser::Identifier) {
            setState(1542);
            constantExpression();
          }
          setState(1545);
          match(CPP14Parser::RightBracket);
          setState(1547);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 200, _ctx)) {
          case 1: {
            setState(1546);
            attributeSpecifierSeq();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        } 
      }
      setState(1555);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 202, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- AbstractPackDeclaratorContext ------------------------------------------------------------------

CPP14Parser::AbstractPackDeclaratorContext::AbstractPackDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::AbstractPackDeclaratorContext::noPointerAbstractPackDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerAbstractPackDeclaratorContext>(0);
}

std::vector<CPP14Parser::PointerOperatorContext *> CPP14Parser::AbstractPackDeclaratorContext::pointerOperator() {
  return getRuleContexts<CPP14Parser::PointerOperatorContext>();
}

CPP14Parser::PointerOperatorContext* CPP14Parser::AbstractPackDeclaratorContext::pointerOperator(size_t i) {
  return getRuleContext<CPP14Parser::PointerOperatorContext>(i);
}


size_t CPP14Parser::AbstractPackDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleAbstractPackDeclarator;
}


std::any CPP14Parser::AbstractPackDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAbstractPackDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AbstractPackDeclaratorContext* CPP14Parser::abstractPackDeclarator() {
  AbstractPackDeclaratorContext *_localctx = _tracker.createInstance<AbstractPackDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 254, CPP14Parser::RuleAbstractPackDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1559);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Decltype || (((_la - 93) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 93)) & 566969237521) != 0) {
      setState(1556);
      pointerOperator();
      setState(1561);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1562);
    noPointerAbstractPackDeclarator(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoPointerAbstractPackDeclaratorContext ------------------------------------------------------------------

CPP14Parser::NoPointerAbstractPackDeclaratorContext::NoPointerAbstractPackDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}

CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::noPointerAbstractPackDeclarator() {
  return getRuleContext<CPP14Parser::NoPointerAbstractPackDeclaratorContext>(0);
}

CPP14Parser::ParametersAndQualifiersContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::parametersAndQualifiers() {
  return getRuleContext<CPP14Parser::ParametersAndQualifiersContext>(0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::NoPointerAbstractPackDeclaratorContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::NoPointerAbstractPackDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::NoPointerAbstractPackDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleNoPointerAbstractPackDeclarator;
}


std::any CPP14Parser::NoPointerAbstractPackDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoPointerAbstractPackDeclarator(this);
  else
    return visitor->visitChildren(this);
}


CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::noPointerAbstractPackDeclarator() {
   return noPointerAbstractPackDeclarator(0);
}

CPP14Parser::NoPointerAbstractPackDeclaratorContext* CPP14Parser::noPointerAbstractPackDeclarator(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CPP14Parser::NoPointerAbstractPackDeclaratorContext *_localctx = _tracker.createInstance<NoPointerAbstractPackDeclaratorContext>(_ctx, parentState);
  CPP14Parser::NoPointerAbstractPackDeclaratorContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 256;
  enterRecursionRule(_localctx, 256, CPP14Parser::RuleNoPointerAbstractPackDeclarator, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1565);
    match(CPP14Parser::Ellipsis);
    _ctx->stop = _input->LT(-1);
    setState(1581);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<NoPointerAbstractPackDeclaratorContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleNoPointerAbstractPackDeclarator);
        setState(1567);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(1577);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case CPP14Parser::LeftParen: {
            setState(1568);
            parametersAndQualifiers();
            break;
          }

          case CPP14Parser::LeftBracket: {
            setState(1569);
            match(CPP14Parser::LeftBracket);
            setState(1571);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (((_la & ~ 0x3fULL) == 0) &&
              ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
              ((1ULL << (_la - 65)) & 4719772474384133137) != 0 || _la == CPP14Parser::Identifier) {
              setState(1570);
              constantExpression();
            }
            setState(1573);
            match(CPP14Parser::RightBracket);
            setState(1575);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
            case 1: {
              setState(1574);
              attributeSpecifierSeq();
              break;
            }

            default:
              break;
            }
            break;
          }

        default:
          throw NoViableAltException(this);
        } 
      }
      setState(1583);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- ParameterDeclarationClauseContext ------------------------------------------------------------------

CPP14Parser::ParameterDeclarationClauseContext::ParameterDeclarationClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ParameterDeclarationListContext* CPP14Parser::ParameterDeclarationClauseContext::parameterDeclarationList() {
  return getRuleContext<CPP14Parser::ParameterDeclarationListContext>(0);
}

tree::TerminalNode* CPP14Parser::ParameterDeclarationClauseContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}

tree::TerminalNode* CPP14Parser::ParameterDeclarationClauseContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}


size_t CPP14Parser::ParameterDeclarationClauseContext::getRuleIndex() const {
  return CPP14Parser::RuleParameterDeclarationClause;
}


std::any CPP14Parser::ParameterDeclarationClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitParameterDeclarationClause(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ParameterDeclarationClauseContext* CPP14Parser::parameterDeclarationClause() {
  ParameterDeclarationClauseContext *_localctx = _tracker.createInstance<ParameterDeclarationClauseContext>(_ctx, getState());
  enterRule(_localctx, 258, CPP14Parser::RuleParameterDeclarationClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1584);
    parameterDeclarationList();
    setState(1589);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Comma

    || _la == CPP14Parser::Ellipsis) {
      setState(1586);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Comma) {
        setState(1585);
        match(CPP14Parser::Comma);
      }
      setState(1588);
      match(CPP14Parser::Ellipsis);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParameterDeclarationListContext ------------------------------------------------------------------

CPP14Parser::ParameterDeclarationListContext::ParameterDeclarationListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::ParameterDeclarationContext *> CPP14Parser::ParameterDeclarationListContext::parameterDeclaration() {
  return getRuleContexts<CPP14Parser::ParameterDeclarationContext>();
}

CPP14Parser::ParameterDeclarationContext* CPP14Parser::ParameterDeclarationListContext::parameterDeclaration(size_t i) {
  return getRuleContext<CPP14Parser::ParameterDeclarationContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::ParameterDeclarationListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::ParameterDeclarationListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::ParameterDeclarationListContext::getRuleIndex() const {
  return CPP14Parser::RuleParameterDeclarationList;
}


std::any CPP14Parser::ParameterDeclarationListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitParameterDeclarationList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ParameterDeclarationListContext* CPP14Parser::parameterDeclarationList() {
  ParameterDeclarationListContext *_localctx = _tracker.createInstance<ParameterDeclarationListContext>(_ctx, getState());
  enterRule(_localctx, 260, CPP14Parser::RuleParameterDeclarationList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1591);
    parameterDeclaration();
    setState(1596);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1592);
        match(CPP14Parser::Comma);
        setState(1593);
        parameterDeclaration(); 
      }
      setState(1598);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParameterDeclarationContext ------------------------------------------------------------------

CPP14Parser::ParameterDeclarationContext::ParameterDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::ParameterDeclarationContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ParameterDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::DeclaratorContext* CPP14Parser::ParameterDeclarationContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

tree::TerminalNode* CPP14Parser::ParameterDeclarationContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::InitializerClauseContext* CPP14Parser::ParameterDeclarationContext::initializerClause() {
  return getRuleContext<CPP14Parser::InitializerClauseContext>(0);
}

CPP14Parser::AbstractDeclaratorContext* CPP14Parser::ParameterDeclarationContext::abstractDeclarator() {
  return getRuleContext<CPP14Parser::AbstractDeclaratorContext>(0);
}


size_t CPP14Parser::ParameterDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleParameterDeclaration;
}


std::any CPP14Parser::ParameterDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitParameterDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ParameterDeclarationContext* CPP14Parser::parameterDeclaration() {
  ParameterDeclarationContext *_localctx = _tracker.createInstance<ParameterDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 262, CPP14Parser::RuleParameterDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1600);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1599);
      attributeSpecifierSeq();
    }
    setState(1602);
    declSpecifierSeq();

    setState(1607);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 213, _ctx)) {
    case 1: {
      setState(1603);
      declarator();
      break;
    }

    case 2: {
      setState(1605);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 212, _ctx)) {
      case 1: {
        setState(1604);
        abstractDeclarator();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
    setState(1611);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Assign) {
      setState(1609);
      match(CPP14Parser::Assign);
      setState(1610);
      initializerClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionDefinitionContext ------------------------------------------------------------------

CPP14Parser::FunctionDefinitionContext::FunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclaratorContext* CPP14Parser::FunctionDefinitionContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

CPP14Parser::FunctionBodyContext* CPP14Parser::FunctionDefinitionContext::functionBody() {
  return getRuleContext<CPP14Parser::FunctionBodyContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::FunctionDefinitionContext::virtualSpecifierSeq() {
  return getRuleContext<CPP14Parser::VirtualSpecifierSeqContext>(0);
}


size_t CPP14Parser::FunctionDefinitionContext::getRuleIndex() const {
  return CPP14Parser::RuleFunctionDefinition;
}


std::any CPP14Parser::FunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitFunctionDefinition(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::FunctionDefinitionContext* CPP14Parser::functionDefinition() {
  FunctionDefinitionContext *_localctx = _tracker.createInstance<FunctionDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 264, CPP14Parser::RuleFunctionDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1614);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1613);
      attributeSpecifierSeq();
    }
    setState(1617);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 216, _ctx)) {
    case 1: {
      setState(1616);
      declSpecifierSeq();
      break;
    }

    default:
      break;
    }
    setState(1619);
    declarator();
    setState(1621);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Final

    || _la == CPP14Parser::Override) {
      setState(1620);
      virtualSpecifierSeq();
    }
    setState(1623);
    functionBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionBodyContext ------------------------------------------------------------------

CPP14Parser::FunctionBodyContext::FunctionBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::CompoundStatementContext* CPP14Parser::FunctionBodyContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}

CPP14Parser::ConstructorInitializerContext* CPP14Parser::FunctionBodyContext::constructorInitializer() {
  return getRuleContext<CPP14Parser::ConstructorInitializerContext>(0);
}

CPP14Parser::FunctionTryBlockContext* CPP14Parser::FunctionBodyContext::functionTryBlock() {
  return getRuleContext<CPP14Parser::FunctionTryBlockContext>(0);
}

tree::TerminalNode* CPP14Parser::FunctionBodyContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

tree::TerminalNode* CPP14Parser::FunctionBodyContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

tree::TerminalNode* CPP14Parser::FunctionBodyContext::Default() {
  return getToken(CPP14Parser::Default, 0);
}

tree::TerminalNode* CPP14Parser::FunctionBodyContext::Delete() {
  return getToken(CPP14Parser::Delete, 0);
}


size_t CPP14Parser::FunctionBodyContext::getRuleIndex() const {
  return CPP14Parser::RuleFunctionBody;
}


std::any CPP14Parser::FunctionBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitFunctionBody(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::FunctionBodyContext* CPP14Parser::functionBody() {
  FunctionBodyContext *_localctx = _tracker.createInstance<FunctionBodyContext>(_ctx, getState());
  enterRule(_localctx, 266, CPP14Parser::RuleFunctionBody);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1633);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftBrace:
      case CPP14Parser::Colon: {
        enterOuterAlt(_localctx, 1);
        setState(1626);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Colon) {
          setState(1625);
          constructorInitializer();
        }
        setState(1628);
        compoundStatement();
        break;
      }

      case CPP14Parser::Try: {
        enterOuterAlt(_localctx, 2);
        setState(1629);
        functionTryBlock();
        break;
      }

      case CPP14Parser::Assign: {
        enterOuterAlt(_localctx, 3);
        setState(1630);
        match(CPP14Parser::Assign);
        setState(1631);
        _la = _input->LA(1);
        if (!(_la == CPP14Parser::Default

        || _la == CPP14Parser::Delete)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1632);
        match(CPP14Parser::Semi);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitializerContext ------------------------------------------------------------------

CPP14Parser::InitializerContext::InitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::InitializerContext::braceOrEqualInitializer() {
  return getRuleContext<CPP14Parser::BraceOrEqualInitializerContext>(0);
}

tree::TerminalNode* CPP14Parser::InitializerContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ExpressionListContext* CPP14Parser::InitializerContext::expressionList() {
  return getRuleContext<CPP14Parser::ExpressionListContext>(0);
}

tree::TerminalNode* CPP14Parser::InitializerContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::InitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleInitializer;
}


std::any CPP14Parser::InitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitializerContext* CPP14Parser::initializer() {
  InitializerContext *_localctx = _tracker.createInstance<InitializerContext>(_ctx, getState());
  enterRule(_localctx, 268, CPP14Parser::RuleInitializer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1640);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftBrace:
      case CPP14Parser::Assign: {
        enterOuterAlt(_localctx, 1);
        setState(1635);
        braceOrEqualInitializer();
        break;
      }

      case CPP14Parser::LeftParen: {
        enterOuterAlt(_localctx, 2);
        setState(1636);
        match(CPP14Parser::LeftParen);
        setState(1637);
        expressionList();
        setState(1638);
        match(CPP14Parser::RightParen);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BraceOrEqualInitializerContext ------------------------------------------------------------------

CPP14Parser::BraceOrEqualInitializerContext::BraceOrEqualInitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::BraceOrEqualInitializerContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::InitializerClauseContext* CPP14Parser::BraceOrEqualInitializerContext::initializerClause() {
  return getRuleContext<CPP14Parser::InitializerClauseContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::BraceOrEqualInitializerContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}


size_t CPP14Parser::BraceOrEqualInitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleBraceOrEqualInitializer;
}


std::any CPP14Parser::BraceOrEqualInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBraceOrEqualInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::braceOrEqualInitializer() {
  BraceOrEqualInitializerContext *_localctx = _tracker.createInstance<BraceOrEqualInitializerContext>(_ctx, getState());
  enterRule(_localctx, 270, CPP14Parser::RuleBraceOrEqualInitializer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1645);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Assign: {
        enterOuterAlt(_localctx, 1);
        setState(1642);
        match(CPP14Parser::Assign);
        setState(1643);
        initializerClause();
        break;
      }

      case CPP14Parser::LeftBrace: {
        enterOuterAlt(_localctx, 2);
        setState(1644);
        bracedInitList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitializerClauseContext ------------------------------------------------------------------

CPP14Parser::InitializerClauseContext::InitializerClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::AssignmentExpressionContext* CPP14Parser::InitializerClauseContext::assignmentExpression() {
  return getRuleContext<CPP14Parser::AssignmentExpressionContext>(0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::InitializerClauseContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}


size_t CPP14Parser::InitializerClauseContext::getRuleIndex() const {
  return CPP14Parser::RuleInitializerClause;
}


std::any CPP14Parser::InitializerClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitializerClause(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitializerClauseContext* CPP14Parser::initializerClause() {
  InitializerClauseContext *_localctx = _tracker.createInstance<InitializerClauseContext>(_ctx, getState());
  enterRule(_localctx, 272, CPP14Parser::RuleInitializerClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1649);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::IntegerLiteral:
      case CPP14Parser::CharacterLiteral:
      case CPP14Parser::FloatingLiteral:
      case CPP14Parser::StringLiteral:
      case CPP14Parser::BooleanLiteral:
      case CPP14Parser::PointerLiteral:
      case CPP14Parser::UserDefinedLiteral:
      case CPP14Parser::Alignof:
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Const_cast:
      case CPP14Parser::Decltype:
      case CPP14Parser::Delete:
      case CPP14Parser::Double:
      case CPP14Parser::Dynamic_cast:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::New:
      case CPP14Parser::Noexcept:
      case CPP14Parser::Operator:
      case CPP14Parser::Reinterpret_cast:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Sizeof:
      case CPP14Parser::Static_cast:
      case CPP14Parser::This:
      case CPP14Parser::Throw:
      case CPP14Parser::Typeid_:
      case CPP14Parser::Typename_:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Wchar:
      case CPP14Parser::LeftParen:
      case CPP14Parser::LeftBracket:
      case CPP14Parser::Plus:
      case CPP14Parser::Minus:
      case CPP14Parser::Star:
      case CPP14Parser::And:
      case CPP14Parser::Or:
      case CPP14Parser::Tilde:
      case CPP14Parser::Not:
      case CPP14Parser::PlusPlus:
      case CPP14Parser::MinusMinus:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(1647);
        assignmentExpression();
        break;
      }

      case CPP14Parser::LeftBrace: {
        enterOuterAlt(_localctx, 2);
        setState(1648);
        bracedInitList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitializerListContext ------------------------------------------------------------------

CPP14Parser::InitializerListContext::InitializerListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::InitializerClauseContext *> CPP14Parser::InitializerListContext::initializerClause() {
  return getRuleContexts<CPP14Parser::InitializerClauseContext>();
}

CPP14Parser::InitializerClauseContext* CPP14Parser::InitializerListContext::initializerClause(size_t i) {
  return getRuleContext<CPP14Parser::InitializerClauseContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::InitializerListContext::Ellipsis() {
  return getTokens(CPP14Parser::Ellipsis);
}

tree::TerminalNode* CPP14Parser::InitializerListContext::Ellipsis(size_t i) {
  return getToken(CPP14Parser::Ellipsis, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::InitializerListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::InitializerListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::InitializerListContext::getRuleIndex() const {
  return CPP14Parser::RuleInitializerList;
}


std::any CPP14Parser::InitializerListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitInitializerList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::InitializerListContext* CPP14Parser::initializerList() {
  InitializerListContext *_localctx = _tracker.createInstance<InitializerListContext>(_ctx, getState());
  enterRule(_localctx, 274, CPP14Parser::RuleInitializerList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1651);
    initializerClause();
    setState(1653);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1652);
      match(CPP14Parser::Ellipsis);
    }
    setState(1662);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1655);
        match(CPP14Parser::Comma);
        setState(1656);
        initializerClause();
        setState(1658);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Ellipsis) {
          setState(1657);
          match(CPP14Parser::Ellipsis);
        } 
      }
      setState(1664);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BracedInitListContext ------------------------------------------------------------------

CPP14Parser::BracedInitListContext::BracedInitListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::BracedInitListContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::BracedInitListContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

CPP14Parser::InitializerListContext* CPP14Parser::BracedInitListContext::initializerList() {
  return getRuleContext<CPP14Parser::InitializerListContext>(0);
}

tree::TerminalNode* CPP14Parser::BracedInitListContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}


size_t CPP14Parser::BracedInitListContext::getRuleIndex() const {
  return CPP14Parser::RuleBracedInitList;
}


std::any CPP14Parser::BracedInitListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBracedInitList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BracedInitListContext* CPP14Parser::bracedInitList() {
  BracedInitListContext *_localctx = _tracker.createInstance<BracedInitListContext>(_ctx, getState());
  enterRule(_localctx, 276, CPP14Parser::RuleBracedInitList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1665);
    match(CPP14Parser::LeftBrace);
    setState(1670);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & 4719772474400910417) != 0 || _la == CPP14Parser::Identifier) {
      setState(1666);
      initializerList();
      setState(1668);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Comma) {
        setState(1667);
        match(CPP14Parser::Comma);
      }
    }
    setState(1672);
    match(CPP14Parser::RightBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassNameContext ------------------------------------------------------------------

CPP14Parser::ClassNameContext::ClassNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ClassNameContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::ClassNameContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}


size_t CPP14Parser::ClassNameContext::getRuleIndex() const {
  return CPP14Parser::RuleClassName;
}


std::any CPP14Parser::ClassNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassNameContext* CPP14Parser::className() {
  ClassNameContext *_localctx = _tracker.createInstance<ClassNameContext>(_ctx, getState());
  enterRule(_localctx, 278, CPP14Parser::RuleClassName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1676);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1674);
      match(CPP14Parser::Identifier);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1675);
      simpleTemplateId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassSpecifierContext ------------------------------------------------------------------

CPP14Parser::ClassSpecifierContext::ClassSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassHeadContext* CPP14Parser::ClassSpecifierContext::classHead() {
  return getRuleContext<CPP14Parser::ClassHeadContext>(0);
}

tree::TerminalNode* CPP14Parser::ClassSpecifierContext::LeftBrace() {
  return getToken(CPP14Parser::LeftBrace, 0);
}

tree::TerminalNode* CPP14Parser::ClassSpecifierContext::RightBrace() {
  return getToken(CPP14Parser::RightBrace, 0);
}

CPP14Parser::MemberSpecificationContext* CPP14Parser::ClassSpecifierContext::memberSpecification() {
  return getRuleContext<CPP14Parser::MemberSpecificationContext>(0);
}


size_t CPP14Parser::ClassSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleClassSpecifier;
}


std::any CPP14Parser::ClassSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassSpecifierContext* CPP14Parser::classSpecifier() {
  ClassSpecifierContext *_localctx = _tracker.createInstance<ClassSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 280, CPP14Parser::RuleClassSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1678);
    classHead();
    setState(1679);
    match(CPP14Parser::LeftBrace);
    setState(1681);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1543877313594212121) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 463888353847684093) != 0) {
      setState(1680);
      memberSpecification();
    }
    setState(1683);
    match(CPP14Parser::RightBrace);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassHeadContext ------------------------------------------------------------------

CPP14Parser::ClassHeadContext::ClassHeadContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassKeyContext* CPP14Parser::ClassHeadContext::classKey() {
  return getRuleContext<CPP14Parser::ClassKeyContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ClassHeadContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::ClassHeadNameContext* CPP14Parser::ClassHeadContext::classHeadName() {
  return getRuleContext<CPP14Parser::ClassHeadNameContext>(0);
}

CPP14Parser::BaseClauseContext* CPP14Parser::ClassHeadContext::baseClause() {
  return getRuleContext<CPP14Parser::BaseClauseContext>(0);
}

CPP14Parser::ClassVirtSpecifierContext* CPP14Parser::ClassHeadContext::classVirtSpecifier() {
  return getRuleContext<CPP14Parser::ClassVirtSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::ClassHeadContext::Union() {
  return getToken(CPP14Parser::Union, 0);
}


size_t CPP14Parser::ClassHeadContext::getRuleIndex() const {
  return CPP14Parser::RuleClassHead;
}


std::any CPP14Parser::ClassHeadContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassHead(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassHeadContext* CPP14Parser::classHead() {
  ClassHeadContext *_localctx = _tracker.createInstance<ClassHeadContext>(_ctx, getState());
  enterRule(_localctx, 282, CPP14Parser::RuleClassHead);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1708);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Class:
      case CPP14Parser::Struct: {
        enterOuterAlt(_localctx, 1);
        setState(1685);
        classKey();
        setState(1687);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
          setState(1686);
          attributeSpecifierSeq();
        }
        setState(1693);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon

        || _la == CPP14Parser::Identifier) {
          setState(1689);
          classHeadName();
          setState(1691);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CPP14Parser::Final) {
            setState(1690);
            classVirtSpecifier();
          }
        }
        setState(1696);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Colon) {
          setState(1695);
          baseClause();
        }
        break;
      }

      case CPP14Parser::Union: {
        enterOuterAlt(_localctx, 2);
        setState(1698);
        match(CPP14Parser::Union);
        setState(1700);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
          setState(1699);
          attributeSpecifierSeq();
        }
        setState(1706);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Decltype || _la == CPP14Parser::Doublecolon

        || _la == CPP14Parser::Identifier) {
          setState(1702);
          classHeadName();
          setState(1704);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CPP14Parser::Final) {
            setState(1703);
            classVirtSpecifier();
          }
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassHeadNameContext ------------------------------------------------------------------

CPP14Parser::ClassHeadNameContext::ClassHeadNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassNameContext* CPP14Parser::ClassHeadNameContext::className() {
  return getRuleContext<CPP14Parser::ClassNameContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ClassHeadNameContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}


size_t CPP14Parser::ClassHeadNameContext::getRuleIndex() const {
  return CPP14Parser::RuleClassHeadName;
}


std::any CPP14Parser::ClassHeadNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassHeadName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassHeadNameContext* CPP14Parser::classHeadName() {
  ClassHeadNameContext *_localctx = _tracker.createInstance<ClassHeadNameContext>(_ctx, getState());
  enterRule(_localctx, 284, CPP14Parser::RuleClassHeadName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1711);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 238, _ctx)) {
    case 1: {
      setState(1710);
      nestedNameSpecifier(0);
      break;
    }

    default:
      break;
    }
    setState(1713);
    className();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassVirtSpecifierContext ------------------------------------------------------------------

CPP14Parser::ClassVirtSpecifierContext::ClassVirtSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ClassVirtSpecifierContext::Final() {
  return getToken(CPP14Parser::Final, 0);
}


size_t CPP14Parser::ClassVirtSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleClassVirtSpecifier;
}


std::any CPP14Parser::ClassVirtSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassVirtSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassVirtSpecifierContext* CPP14Parser::classVirtSpecifier() {
  ClassVirtSpecifierContext *_localctx = _tracker.createInstance<ClassVirtSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 286, CPP14Parser::RuleClassVirtSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1715);
    match(CPP14Parser::Final);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassKeyContext ------------------------------------------------------------------

CPP14Parser::ClassKeyContext::ClassKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ClassKeyContext::Class() {
  return getToken(CPP14Parser::Class, 0);
}

tree::TerminalNode* CPP14Parser::ClassKeyContext::Struct() {
  return getToken(CPP14Parser::Struct, 0);
}


size_t CPP14Parser::ClassKeyContext::getRuleIndex() const {
  return CPP14Parser::RuleClassKey;
}


std::any CPP14Parser::ClassKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassKey(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassKeyContext* CPP14Parser::classKey() {
  ClassKeyContext *_localctx = _tracker.createInstance<ClassKeyContext>(_ctx, getState());
  enterRule(_localctx, 288, CPP14Parser::RuleClassKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1717);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::Class

    || _la == CPP14Parser::Struct)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemberSpecificationContext ------------------------------------------------------------------

CPP14Parser::MemberSpecificationContext::MemberSpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::MemberdeclarationContext *> CPP14Parser::MemberSpecificationContext::memberdeclaration() {
  return getRuleContexts<CPP14Parser::MemberdeclarationContext>();
}

CPP14Parser::MemberdeclarationContext* CPP14Parser::MemberSpecificationContext::memberdeclaration(size_t i) {
  return getRuleContext<CPP14Parser::MemberdeclarationContext>(i);
}

std::vector<CPP14Parser::AccessSpecifierContext *> CPP14Parser::MemberSpecificationContext::accessSpecifier() {
  return getRuleContexts<CPP14Parser::AccessSpecifierContext>();
}

CPP14Parser::AccessSpecifierContext* CPP14Parser::MemberSpecificationContext::accessSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::AccessSpecifierContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MemberSpecificationContext::Colon() {
  return getTokens(CPP14Parser::Colon);
}

tree::TerminalNode* CPP14Parser::MemberSpecificationContext::Colon(size_t i) {
  return getToken(CPP14Parser::Colon, i);
}


size_t CPP14Parser::MemberSpecificationContext::getRuleIndex() const {
  return CPP14Parser::RuleMemberSpecification;
}


std::any CPP14Parser::MemberSpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemberSpecification(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemberSpecificationContext* CPP14Parser::memberSpecification() {
  MemberSpecificationContext *_localctx = _tracker.createInstance<MemberSpecificationContext>(_ctx, getState());
  enterRule(_localctx, 290, CPP14Parser::RuleMemberSpecification);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1723); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1723);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CPP14Parser::Alignas:
        case CPP14Parser::Auto:
        case CPP14Parser::Bool:
        case CPP14Parser::Char:
        case CPP14Parser::Char16:
        case CPP14Parser::Char32:
        case CPP14Parser::Class:
        case CPP14Parser::Const:
        case CPP14Parser::Constexpr:
        case CPP14Parser::Decltype:
        case CPP14Parser::Double:
        case CPP14Parser::Enum:
        case CPP14Parser::Explicit:
        case CPP14Parser::Extern:
        case CPP14Parser::Float:
        case CPP14Parser::Friend:
        case CPP14Parser::Inline:
        case CPP14Parser::Int:
        case CPP14Parser::Long:
        case CPP14Parser::Mutable:
        case CPP14Parser::Operator:
        case CPP14Parser::Register:
        case CPP14Parser::Short:
        case CPP14Parser::Signed:
        case CPP14Parser::Static:
        case CPP14Parser::Static_assert:
        case CPP14Parser::Struct:
        case CPP14Parser::Template:
        case CPP14Parser::Thread_local:
        case CPP14Parser::Typedef:
        case CPP14Parser::Typename_:
        case CPP14Parser::Union:
        case CPP14Parser::Unsigned:
        case CPP14Parser::Using:
        case CPP14Parser::Virtual:
        case CPP14Parser::Void:
        case CPP14Parser::Volatile:
        case CPP14Parser::Wchar:
        case CPP14Parser::LeftParen:
        case CPP14Parser::LeftBracket:
        case CPP14Parser::Star:
        case CPP14Parser::And:
        case CPP14Parser::Tilde:
        case CPP14Parser::AndAnd:
        case CPP14Parser::Colon:
        case CPP14Parser::Doublecolon:
        case CPP14Parser::Semi:
        case CPP14Parser::Ellipsis:
        case CPP14Parser::Identifier: {
          setState(1719);
          memberdeclaration();
          break;
        }

        case CPP14Parser::Private:
        case CPP14Parser::Protected:
        case CPP14Parser::Public: {
          setState(1720);
          accessSpecifier();
          setState(1721);
          match(CPP14Parser::Colon);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(1725); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while ((((_la - 10) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 10)) & 1543877313594212121) != 0 || (((_la - 74) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 74)) & 463888353847684093) != 0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemberdeclarationContext ------------------------------------------------------------------

CPP14Parser::MemberdeclarationContext::MemberdeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::MemberdeclarationContext::Semi() {
  return getToken(CPP14Parser::Semi, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::MemberdeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::DeclSpecifierSeqContext* CPP14Parser::MemberdeclarationContext::declSpecifierSeq() {
  return getRuleContext<CPP14Parser::DeclSpecifierSeqContext>(0);
}

CPP14Parser::MemberDeclaratorListContext* CPP14Parser::MemberdeclarationContext::memberDeclaratorList() {
  return getRuleContext<CPP14Parser::MemberDeclaratorListContext>(0);
}

CPP14Parser::FunctionDefinitionContext* CPP14Parser::MemberdeclarationContext::functionDefinition() {
  return getRuleContext<CPP14Parser::FunctionDefinitionContext>(0);
}

CPP14Parser::UsingDeclarationContext* CPP14Parser::MemberdeclarationContext::usingDeclaration() {
  return getRuleContext<CPP14Parser::UsingDeclarationContext>(0);
}

CPP14Parser::StaticAssertDeclarationContext* CPP14Parser::MemberdeclarationContext::staticAssertDeclaration() {
  return getRuleContext<CPP14Parser::StaticAssertDeclarationContext>(0);
}

CPP14Parser::TemplateDeclarationContext* CPP14Parser::MemberdeclarationContext::templateDeclaration() {
  return getRuleContext<CPP14Parser::TemplateDeclarationContext>(0);
}

CPP14Parser::AliasDeclarationContext* CPP14Parser::MemberdeclarationContext::aliasDeclaration() {
  return getRuleContext<CPP14Parser::AliasDeclarationContext>(0);
}

CPP14Parser::EmptyDeclarationContext* CPP14Parser::MemberdeclarationContext::emptyDeclaration() {
  return getRuleContext<CPP14Parser::EmptyDeclarationContext>(0);
}


size_t CPP14Parser::MemberdeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleMemberdeclaration;
}


std::any CPP14Parser::MemberdeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemberdeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemberdeclarationContext* CPP14Parser::memberdeclaration() {
  MemberdeclarationContext *_localctx = _tracker.createInstance<MemberdeclarationContext>(_ctx, getState());
  enterRule(_localctx, 292, CPP14Parser::RuleMemberdeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1743);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 244, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1728);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 241, _ctx)) {
      case 1: {
        setState(1727);
        attributeSpecifierSeq();
        break;
      }

      default:
        break;
      }
      setState(1731);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 242, _ctx)) {
      case 1: {
        setState(1730);
        declSpecifierSeq();
        break;
      }

      default:
        break;
      }
      setState(1734);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 4503599694480384) != 0 || (((_la - 85) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 85)) & 217711892254981) != 0) {
        setState(1733);
        memberDeclaratorList();
      }
      setState(1736);
      match(CPP14Parser::Semi);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1737);
      functionDefinition();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1738);
      usingDeclaration();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1739);
      staticAssertDeclaration();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1740);
      templateDeclaration();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1741);
      aliasDeclaration();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1742);
      emptyDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemberDeclaratorListContext ------------------------------------------------------------------

CPP14Parser::MemberDeclaratorListContext::MemberDeclaratorListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::MemberDeclaratorContext *> CPP14Parser::MemberDeclaratorListContext::memberDeclarator() {
  return getRuleContexts<CPP14Parser::MemberDeclaratorContext>();
}

CPP14Parser::MemberDeclaratorContext* CPP14Parser::MemberDeclaratorListContext::memberDeclarator(size_t i) {
  return getRuleContext<CPP14Parser::MemberDeclaratorContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MemberDeclaratorListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::MemberDeclaratorListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::MemberDeclaratorListContext::getRuleIndex() const {
  return CPP14Parser::RuleMemberDeclaratorList;
}


std::any CPP14Parser::MemberDeclaratorListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemberDeclaratorList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemberDeclaratorListContext* CPP14Parser::memberDeclaratorList() {
  MemberDeclaratorListContext *_localctx = _tracker.createInstance<MemberDeclaratorListContext>(_ctx, getState());
  enterRule(_localctx, 294, CPP14Parser::RuleMemberDeclaratorList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1745);
    memberDeclarator();
    setState(1750);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1746);
      match(CPP14Parser::Comma);
      setState(1747);
      memberDeclarator();
      setState(1752);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemberDeclaratorContext ------------------------------------------------------------------

CPP14Parser::MemberDeclaratorContext::MemberDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DeclaratorContext* CPP14Parser::MemberDeclaratorContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::MemberDeclaratorContext::virtualSpecifierSeq() {
  return getRuleContext<CPP14Parser::VirtualSpecifierSeqContext>(0);
}

CPP14Parser::PureSpecifierContext* CPP14Parser::MemberDeclaratorContext::pureSpecifier() {
  return getRuleContext<CPP14Parser::PureSpecifierContext>(0);
}

CPP14Parser::BraceOrEqualInitializerContext* CPP14Parser::MemberDeclaratorContext::braceOrEqualInitializer() {
  return getRuleContext<CPP14Parser::BraceOrEqualInitializerContext>(0);
}

tree::TerminalNode* CPP14Parser::MemberDeclaratorContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::MemberDeclaratorContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::MemberDeclaratorContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::MemberDeclaratorContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::MemberDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleMemberDeclarator;
}


std::any CPP14Parser::MemberDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemberDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemberDeclaratorContext* CPP14Parser::memberDeclarator() {
  MemberDeclaratorContext *_localctx = _tracker.createInstance<MemberDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 296, CPP14Parser::RuleMemberDeclarator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1773);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1753);
      declarator();
      setState(1763);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 249, _ctx)) {
      case 1: {
        setState(1755);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Final

        || _la == CPP14Parser::Override) {
          setState(1754);
          virtualSpecifierSeq();
        }
        setState(1758);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Assign) {
          setState(1757);
          pureSpecifier();
        }
        break;
      }

      case 2: {
        setState(1761);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::LeftBrace

        || _la == CPP14Parser::Assign) {
          setState(1760);
          braceOrEqualInitializer();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1766);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Identifier) {
        setState(1765);
        match(CPP14Parser::Identifier);
      }
      setState(1769);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
        setState(1768);
        attributeSpecifierSeq();
      }
      setState(1771);
      match(CPP14Parser::Colon);
      setState(1772);
      constantExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VirtualSpecifierSeqContext ------------------------------------------------------------------

CPP14Parser::VirtualSpecifierSeqContext::VirtualSpecifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::VirtualSpecifierContext *> CPP14Parser::VirtualSpecifierSeqContext::virtualSpecifier() {
  return getRuleContexts<CPP14Parser::VirtualSpecifierContext>();
}

CPP14Parser::VirtualSpecifierContext* CPP14Parser::VirtualSpecifierSeqContext::virtualSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::VirtualSpecifierContext>(i);
}


size_t CPP14Parser::VirtualSpecifierSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleVirtualSpecifierSeq;
}


std::any CPP14Parser::VirtualSpecifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitVirtualSpecifierSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::VirtualSpecifierSeqContext* CPP14Parser::virtualSpecifierSeq() {
  VirtualSpecifierSeqContext *_localctx = _tracker.createInstance<VirtualSpecifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 298, CPP14Parser::RuleVirtualSpecifierSeq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1776); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1775);
      virtualSpecifier();
      setState(1778); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == CPP14Parser::Final

    || _la == CPP14Parser::Override);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VirtualSpecifierContext ------------------------------------------------------------------

CPP14Parser::VirtualSpecifierContext::VirtualSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::VirtualSpecifierContext::Override() {
  return getToken(CPP14Parser::Override, 0);
}

tree::TerminalNode* CPP14Parser::VirtualSpecifierContext::Final() {
  return getToken(CPP14Parser::Final, 0);
}


size_t CPP14Parser::VirtualSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleVirtualSpecifier;
}


std::any CPP14Parser::VirtualSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitVirtualSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::VirtualSpecifierContext* CPP14Parser::virtualSpecifier() {
  VirtualSpecifierContext *_localctx = _tracker.createInstance<VirtualSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 300, CPP14Parser::RuleVirtualSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1780);
    _la = _input->LA(1);
    if (!(_la == CPP14Parser::Final

    || _la == CPP14Parser::Override)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PureSpecifierContext ------------------------------------------------------------------

CPP14Parser::PureSpecifierContext::PureSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::PureSpecifierContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

tree::TerminalNode* CPP14Parser::PureSpecifierContext::OctalLiteral() {
  return getToken(CPP14Parser::OctalLiteral, 0);
}


size_t CPP14Parser::PureSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RulePureSpecifier;
}


std::any CPP14Parser::PureSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitPureSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::PureSpecifierContext* CPP14Parser::pureSpecifier() {
  PureSpecifierContext *_localctx = _tracker.createInstance<PureSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 302, CPP14Parser::RulePureSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1782);
    match(CPP14Parser::Assign);
    setState(1783);
    antlrcpp::downCast<PureSpecifierContext *>(_localctx)->val = match(CPP14Parser::OctalLiteral);
    //if((antlrcpp::downCast<PureSpecifierContext *>(_localctx)->val != nullptr ? antlrcpp::downCast<PureSpecifierContext *>(_localctx)->val->getText() : "").compareTo("0")!=0) throw new InputMismatchException(this);
    		
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseClauseContext ------------------------------------------------------------------

CPP14Parser::BaseClauseContext::BaseClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::BaseClauseContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::BaseSpecifierListContext* CPP14Parser::BaseClauseContext::baseSpecifierList() {
  return getRuleContext<CPP14Parser::BaseSpecifierListContext>(0);
}


size_t CPP14Parser::BaseClauseContext::getRuleIndex() const {
  return CPP14Parser::RuleBaseClause;
}


std::any CPP14Parser::BaseClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBaseClause(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BaseClauseContext* CPP14Parser::baseClause() {
  BaseClauseContext *_localctx = _tracker.createInstance<BaseClauseContext>(_ctx, getState());
  enterRule(_localctx, 304, CPP14Parser::RuleBaseClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1786);
    match(CPP14Parser::Colon);
    setState(1787);
    baseSpecifierList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseSpecifierListContext ------------------------------------------------------------------

CPP14Parser::BaseSpecifierListContext::BaseSpecifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::BaseSpecifierContext *> CPP14Parser::BaseSpecifierListContext::baseSpecifier() {
  return getRuleContexts<CPP14Parser::BaseSpecifierContext>();
}

CPP14Parser::BaseSpecifierContext* CPP14Parser::BaseSpecifierListContext::baseSpecifier(size_t i) {
  return getRuleContext<CPP14Parser::BaseSpecifierContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BaseSpecifierListContext::Ellipsis() {
  return getTokens(CPP14Parser::Ellipsis);
}

tree::TerminalNode* CPP14Parser::BaseSpecifierListContext::Ellipsis(size_t i) {
  return getToken(CPP14Parser::Ellipsis, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::BaseSpecifierListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::BaseSpecifierListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::BaseSpecifierListContext::getRuleIndex() const {
  return CPP14Parser::RuleBaseSpecifierList;
}


std::any CPP14Parser::BaseSpecifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBaseSpecifierList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BaseSpecifierListContext* CPP14Parser::baseSpecifierList() {
  BaseSpecifierListContext *_localctx = _tracker.createInstance<BaseSpecifierListContext>(_ctx, getState());
  enterRule(_localctx, 306, CPP14Parser::RuleBaseSpecifierList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1789);
    baseSpecifier();
    setState(1791);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1790);
      match(CPP14Parser::Ellipsis);
    }
    setState(1800);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1793);
      match(CPP14Parser::Comma);
      setState(1794);
      baseSpecifier();
      setState(1796);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Ellipsis) {
        setState(1795);
        match(CPP14Parser::Ellipsis);
      }
      setState(1802);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseSpecifierContext ------------------------------------------------------------------

CPP14Parser::BaseSpecifierContext::BaseSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::BaseTypeSpecifierContext* CPP14Parser::BaseSpecifierContext::baseTypeSpecifier() {
  return getRuleContext<CPP14Parser::BaseTypeSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::BaseSpecifierContext::Virtual() {
  return getToken(CPP14Parser::Virtual, 0);
}

CPP14Parser::AccessSpecifierContext* CPP14Parser::BaseSpecifierContext::accessSpecifier() {
  return getRuleContext<CPP14Parser::AccessSpecifierContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::BaseSpecifierContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}


size_t CPP14Parser::BaseSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleBaseSpecifier;
}


std::any CPP14Parser::BaseSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBaseSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BaseSpecifierContext* CPP14Parser::baseSpecifier() {
  BaseSpecifierContext *_localctx = _tracker.createInstance<BaseSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 308, CPP14Parser::RuleBaseSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1804);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
      setState(1803);
      attributeSpecifierSeq();
    }
    setState(1818);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Decltype:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        setState(1806);
        baseTypeSpecifier();
        break;
      }

      case CPP14Parser::Virtual: {
        setState(1807);
        match(CPP14Parser::Virtual);
        setState(1809);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 126100789566373888) != 0) {
          setState(1808);
          accessSpecifier();
        }
        setState(1811);
        baseTypeSpecifier();
        break;
      }

      case CPP14Parser::Private:
      case CPP14Parser::Protected:
      case CPP14Parser::Public: {
        setState(1812);
        accessSpecifier();
        setState(1814);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Virtual) {
          setState(1813);
          match(CPP14Parser::Virtual);
        }
        setState(1816);
        baseTypeSpecifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ClassOrDeclTypeContext ------------------------------------------------------------------

CPP14Parser::ClassOrDeclTypeContext::ClassOrDeclTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassNameContext* CPP14Parser::ClassOrDeclTypeContext::className() {
  return getRuleContext<CPP14Parser::ClassNameContext>(0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::ClassOrDeclTypeContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

CPP14Parser::DecltypeSpecifierContext* CPP14Parser::ClassOrDeclTypeContext::decltypeSpecifier() {
  return getRuleContext<CPP14Parser::DecltypeSpecifierContext>(0);
}


size_t CPP14Parser::ClassOrDeclTypeContext::getRuleIndex() const {
  return CPP14Parser::RuleClassOrDeclType;
}


std::any CPP14Parser::ClassOrDeclTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitClassOrDeclType(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::classOrDeclType() {
  ClassOrDeclTypeContext *_localctx = _tracker.createInstance<ClassOrDeclTypeContext>(_ctx, getState());
  enterRule(_localctx, 310, CPP14Parser::RuleClassOrDeclType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1825);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1821);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 261, _ctx)) {
      case 1: {
        setState(1820);
        nestedNameSpecifier(0);
        break;
      }

      default:
        break;
      }
      setState(1823);
      className();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1824);
      decltypeSpecifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BaseTypeSpecifierContext ------------------------------------------------------------------

CPP14Parser::BaseTypeSpecifierContext::BaseTypeSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::BaseTypeSpecifierContext::classOrDeclType() {
  return getRuleContext<CPP14Parser::ClassOrDeclTypeContext>(0);
}


size_t CPP14Parser::BaseTypeSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleBaseTypeSpecifier;
}


std::any CPP14Parser::BaseTypeSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitBaseTypeSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::BaseTypeSpecifierContext* CPP14Parser::baseTypeSpecifier() {
  BaseTypeSpecifierContext *_localctx = _tracker.createInstance<BaseTypeSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 312, CPP14Parser::RuleBaseTypeSpecifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1827);
    classOrDeclType();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AccessSpecifierContext ------------------------------------------------------------------

CPP14Parser::AccessSpecifierContext::AccessSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Private() {
  return getToken(CPP14Parser::Private, 0);
}

tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Protected() {
  return getToken(CPP14Parser::Protected, 0);
}

tree::TerminalNode* CPP14Parser::AccessSpecifierContext::Public() {
  return getToken(CPP14Parser::Public, 0);
}


size_t CPP14Parser::AccessSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleAccessSpecifier;
}


std::any CPP14Parser::AccessSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitAccessSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::AccessSpecifierContext* CPP14Parser::accessSpecifier() {
  AccessSpecifierContext *_localctx = _tracker.createInstance<AccessSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 314, CPP14Parser::RuleAccessSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1829);
    _la = _input->LA(1);
    if (!(((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 126100789566373888) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConversionFunctionIdContext ------------------------------------------------------------------

CPP14Parser::ConversionFunctionIdContext::ConversionFunctionIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ConversionFunctionIdContext::Operator() {
  return getToken(CPP14Parser::Operator, 0);
}

CPP14Parser::ConversionTypeIdContext* CPP14Parser::ConversionFunctionIdContext::conversionTypeId() {
  return getRuleContext<CPP14Parser::ConversionTypeIdContext>(0);
}


size_t CPP14Parser::ConversionFunctionIdContext::getRuleIndex() const {
  return CPP14Parser::RuleConversionFunctionId;
}


std::any CPP14Parser::ConversionFunctionIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConversionFunctionId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConversionFunctionIdContext* CPP14Parser::conversionFunctionId() {
  ConversionFunctionIdContext *_localctx = _tracker.createInstance<ConversionFunctionIdContext>(_ctx, getState());
  enterRule(_localctx, 316, CPP14Parser::RuleConversionFunctionId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1831);
    match(CPP14Parser::Operator);
    setState(1832);
    conversionTypeId();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConversionTypeIdContext ------------------------------------------------------------------

CPP14Parser::ConversionTypeIdContext::ConversionTypeIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::ConversionTypeIdContext::typeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TypeSpecifierSeqContext>(0);
}

CPP14Parser::ConversionDeclaratorContext* CPP14Parser::ConversionTypeIdContext::conversionDeclarator() {
  return getRuleContext<CPP14Parser::ConversionDeclaratorContext>(0);
}


size_t CPP14Parser::ConversionTypeIdContext::getRuleIndex() const {
  return CPP14Parser::RuleConversionTypeId;
}


std::any CPP14Parser::ConversionTypeIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConversionTypeId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConversionTypeIdContext* CPP14Parser::conversionTypeId() {
  ConversionTypeIdContext *_localctx = _tracker.createInstance<ConversionTypeIdContext>(_ctx, getState());
  enterRule(_localctx, 318, CPP14Parser::RuleConversionTypeId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1834);
    typeSpecifierSeq();
    setState(1836);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 263, _ctx)) {
    case 1: {
      setState(1835);
      conversionDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConversionDeclaratorContext ------------------------------------------------------------------

CPP14Parser::ConversionDeclaratorContext::ConversionDeclaratorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::PointerOperatorContext* CPP14Parser::ConversionDeclaratorContext::pointerOperator() {
  return getRuleContext<CPP14Parser::PointerOperatorContext>(0);
}

CPP14Parser::ConversionDeclaratorContext* CPP14Parser::ConversionDeclaratorContext::conversionDeclarator() {
  return getRuleContext<CPP14Parser::ConversionDeclaratorContext>(0);
}


size_t CPP14Parser::ConversionDeclaratorContext::getRuleIndex() const {
  return CPP14Parser::RuleConversionDeclarator;
}


std::any CPP14Parser::ConversionDeclaratorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConversionDeclarator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConversionDeclaratorContext* CPP14Parser::conversionDeclarator() {
  ConversionDeclaratorContext *_localctx = _tracker.createInstance<ConversionDeclaratorContext>(_ctx, getState());
  enterRule(_localctx, 320, CPP14Parser::RuleConversionDeclarator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1838);
    pointerOperator();
    setState(1840);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx)) {
    case 1: {
      setState(1839);
      conversionDeclarator();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstructorInitializerContext ------------------------------------------------------------------

CPP14Parser::ConstructorInitializerContext::ConstructorInitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ConstructorInitializerContext::Colon() {
  return getToken(CPP14Parser::Colon, 0);
}

CPP14Parser::MemInitializerListContext* CPP14Parser::ConstructorInitializerContext::memInitializerList() {
  return getRuleContext<CPP14Parser::MemInitializerListContext>(0);
}


size_t CPP14Parser::ConstructorInitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleConstructorInitializer;
}


std::any CPP14Parser::ConstructorInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitConstructorInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ConstructorInitializerContext* CPP14Parser::constructorInitializer() {
  ConstructorInitializerContext *_localctx = _tracker.createInstance<ConstructorInitializerContext>(_ctx, getState());
  enterRule(_localctx, 322, CPP14Parser::RuleConstructorInitializer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1842);
    match(CPP14Parser::Colon);
    setState(1843);
    memInitializerList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemInitializerListContext ------------------------------------------------------------------

CPP14Parser::MemInitializerListContext::MemInitializerListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::MemInitializerContext *> CPP14Parser::MemInitializerListContext::memInitializer() {
  return getRuleContexts<CPP14Parser::MemInitializerContext>();
}

CPP14Parser::MemInitializerContext* CPP14Parser::MemInitializerListContext::memInitializer(size_t i) {
  return getRuleContext<CPP14Parser::MemInitializerContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MemInitializerListContext::Ellipsis() {
  return getTokens(CPP14Parser::Ellipsis);
}

tree::TerminalNode* CPP14Parser::MemInitializerListContext::Ellipsis(size_t i) {
  return getToken(CPP14Parser::Ellipsis, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::MemInitializerListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::MemInitializerListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::MemInitializerListContext::getRuleIndex() const {
  return CPP14Parser::RuleMemInitializerList;
}


std::any CPP14Parser::MemInitializerListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemInitializerList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemInitializerListContext* CPP14Parser::memInitializerList() {
  MemInitializerListContext *_localctx = _tracker.createInstance<MemInitializerListContext>(_ctx, getState());
  enterRule(_localctx, 324, CPP14Parser::RuleMemInitializerList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1845);
    memInitializer();
    setState(1847);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1846);
      match(CPP14Parser::Ellipsis);
    }
    setState(1856);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1849);
      match(CPP14Parser::Comma);
      setState(1850);
      memInitializer();
      setState(1852);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Ellipsis) {
        setState(1851);
        match(CPP14Parser::Ellipsis);
      }
      setState(1858);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MemInitializerContext ------------------------------------------------------------------

CPP14Parser::MemInitializerContext::MemInitializerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::MeminitializeridContext* CPP14Parser::MemInitializerContext::meminitializerid() {
  return getRuleContext<CPP14Parser::MeminitializeridContext>(0);
}

tree::TerminalNode* CPP14Parser::MemInitializerContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::MemInitializerContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::BracedInitListContext* CPP14Parser::MemInitializerContext::bracedInitList() {
  return getRuleContext<CPP14Parser::BracedInitListContext>(0);
}

CPP14Parser::ExpressionListContext* CPP14Parser::MemInitializerContext::expressionList() {
  return getRuleContext<CPP14Parser::ExpressionListContext>(0);
}


size_t CPP14Parser::MemInitializerContext::getRuleIndex() const {
  return CPP14Parser::RuleMemInitializer;
}


std::any CPP14Parser::MemInitializerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMemInitializer(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MemInitializerContext* CPP14Parser::memInitializer() {
  MemInitializerContext *_localctx = _tracker.createInstance<MemInitializerContext>(_ctx, getState());
  enterRule(_localctx, 326, CPP14Parser::RuleMemInitializer);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1859);
    meminitializerid();
    setState(1866);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::LeftParen: {
        setState(1860);
        match(CPP14Parser::LeftParen);
        setState(1862);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 65)) & 4719772474400910417) != 0 || _la == CPP14Parser::Identifier) {
          setState(1861);
          expressionList();
        }
        setState(1864);
        match(CPP14Parser::RightParen);
        break;
      }

      case CPP14Parser::LeftBrace: {
        setState(1865);
        bracedInitList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MeminitializeridContext ------------------------------------------------------------------

CPP14Parser::MeminitializeridContext::MeminitializeridContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::ClassOrDeclTypeContext* CPP14Parser::MeminitializeridContext::classOrDeclType() {
  return getRuleContext<CPP14Parser::ClassOrDeclTypeContext>(0);
}

tree::TerminalNode* CPP14Parser::MeminitializeridContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::MeminitializeridContext::getRuleIndex() const {
  return CPP14Parser::RuleMeminitializerid;
}


std::any CPP14Parser::MeminitializeridContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitMeminitializerid(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::MeminitializeridContext* CPP14Parser::meminitializerid() {
  MeminitializeridContext *_localctx = _tracker.createInstance<MeminitializeridContext>(_ctx, getState());
  enterRule(_localctx, 328, CPP14Parser::RuleMeminitializerid);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1870);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1868);
      classOrDeclType();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1869);
      match(CPP14Parser::Identifier);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OperatorFunctionIdContext ------------------------------------------------------------------

CPP14Parser::OperatorFunctionIdContext::OperatorFunctionIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::OperatorFunctionIdContext::Operator() {
  return getToken(CPP14Parser::Operator, 0);
}

CPP14Parser::TheOperatorContext* CPP14Parser::OperatorFunctionIdContext::theOperator() {
  return getRuleContext<CPP14Parser::TheOperatorContext>(0);
}


size_t CPP14Parser::OperatorFunctionIdContext::getRuleIndex() const {
  return CPP14Parser::RuleOperatorFunctionId;
}


std::any CPP14Parser::OperatorFunctionIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitOperatorFunctionId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::OperatorFunctionIdContext* CPP14Parser::operatorFunctionId() {
  OperatorFunctionIdContext *_localctx = _tracker.createInstance<OperatorFunctionIdContext>(_ctx, getState());
  enterRule(_localctx, 330, CPP14Parser::RuleOperatorFunctionId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1872);
    match(CPP14Parser::Operator);
    setState(1873);
    theOperator();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LiteralOperatorIdContext ------------------------------------------------------------------

CPP14Parser::LiteralOperatorIdContext::LiteralOperatorIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::Operator() {
  return getToken(CPP14Parser::Operator, 0);
}

tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::StringLiteral() {
  return getToken(CPP14Parser::StringLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

tree::TerminalNode* CPP14Parser::LiteralOperatorIdContext::UserDefinedStringLiteral() {
  return getToken(CPP14Parser::UserDefinedStringLiteral, 0);
}


size_t CPP14Parser::LiteralOperatorIdContext::getRuleIndex() const {
  return CPP14Parser::RuleLiteralOperatorId;
}


std::any CPP14Parser::LiteralOperatorIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLiteralOperatorId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LiteralOperatorIdContext* CPP14Parser::literalOperatorId() {
  LiteralOperatorIdContext *_localctx = _tracker.createInstance<LiteralOperatorIdContext>(_ctx, getState());
  enterRule(_localctx, 332, CPP14Parser::RuleLiteralOperatorId);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1875);
    match(CPP14Parser::Operator);
    setState(1879);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::StringLiteral: {
        setState(1876);
        match(CPP14Parser::StringLiteral);
        setState(1877);
        match(CPP14Parser::Identifier);
        break;
      }

      case CPP14Parser::UserDefinedStringLiteral: {
        setState(1878);
        match(CPP14Parser::UserDefinedStringLiteral);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateDeclarationContext ------------------------------------------------------------------

CPP14Parser::TemplateDeclarationContext::TemplateDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

CPP14Parser::TemplateparameterListContext* CPP14Parser::TemplateDeclarationContext::templateparameterList() {
  return getRuleContext<CPP14Parser::TemplateparameterListContext>(0);
}

tree::TerminalNode* CPP14Parser::TemplateDeclarationContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

CPP14Parser::DeclarationContext* CPP14Parser::TemplateDeclarationContext::declaration() {
  return getRuleContext<CPP14Parser::DeclarationContext>(0);
}


size_t CPP14Parser::TemplateDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateDeclaration;
}


std::any CPP14Parser::TemplateDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateDeclarationContext* CPP14Parser::templateDeclaration() {
  TemplateDeclarationContext *_localctx = _tracker.createInstance<TemplateDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 334, CPP14Parser::RuleTemplateDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1881);
    match(CPP14Parser::Template);
    setState(1882);
    match(CPP14Parser::Less);
    setState(1883);
    templateparameterList();
    setState(1884);
    match(CPP14Parser::Greater);
    setState(1885);
    declaration();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateparameterListContext ------------------------------------------------------------------

CPP14Parser::TemplateparameterListContext::TemplateparameterListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::TemplateParameterContext *> CPP14Parser::TemplateparameterListContext::templateParameter() {
  return getRuleContexts<CPP14Parser::TemplateParameterContext>();
}

CPP14Parser::TemplateParameterContext* CPP14Parser::TemplateparameterListContext::templateParameter(size_t i) {
  return getRuleContext<CPP14Parser::TemplateParameterContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TemplateparameterListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::TemplateparameterListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::TemplateparameterListContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateparameterList;
}


std::any CPP14Parser::TemplateparameterListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateparameterList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateparameterListContext* CPP14Parser::templateparameterList() {
  TemplateparameterListContext *_localctx = _tracker.createInstance<TemplateparameterListContext>(_ctx, getState());
  enterRule(_localctx, 336, CPP14Parser::RuleTemplateparameterList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1887);
    templateParameter();
    setState(1892);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1888);
      match(CPP14Parser::Comma);
      setState(1889);
      templateParameter();
      setState(1894);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateParameterContext ------------------------------------------------------------------

CPP14Parser::TemplateParameterContext::TemplateParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TypeParameterContext* CPP14Parser::TemplateParameterContext::typeParameter() {
  return getRuleContext<CPP14Parser::TypeParameterContext>(0);
}

CPP14Parser::ParameterDeclarationContext* CPP14Parser::TemplateParameterContext::parameterDeclaration() {
  return getRuleContext<CPP14Parser::ParameterDeclarationContext>(0);
}


size_t CPP14Parser::TemplateParameterContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateParameter;
}


std::any CPP14Parser::TemplateParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateParameter(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateParameterContext* CPP14Parser::templateParameter() {
  TemplateParameterContext *_localctx = _tracker.createInstance<TemplateParameterContext>(_ctx, getState());
  enterRule(_localctx, 338, CPP14Parser::RuleTemplateParameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1897);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 273, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1895);
      typeParameter();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1896);
      parameterDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeParameterContext ------------------------------------------------------------------

CPP14Parser::TypeParameterContext::TypeParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Class() {
  return getToken(CPP14Parser::Class, 0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Typename_() {
  return getToken(CPP14Parser::Typename_, 0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

CPP14Parser::TheTypeIdContext* CPP14Parser::TypeParameterContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

CPP14Parser::TemplateparameterListContext* CPP14Parser::TypeParameterContext::templateparameterList() {
  return getRuleContext<CPP14Parser::TemplateparameterListContext>(0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}

tree::TerminalNode* CPP14Parser::TypeParameterContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::TypeParameterContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeParameter;
}


std::any CPP14Parser::TypeParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeParameter(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeParameterContext* CPP14Parser::typeParameter() {
  TypeParameterContext *_localctx = _tracker.createInstance<TypeParameterContext>(_ctx, getState());
  enterRule(_localctx, 340, CPP14Parser::RuleTypeParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1908);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Class:
      case CPP14Parser::Template: {
        setState(1904);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Template) {
          setState(1899);
          match(CPP14Parser::Template);
          setState(1900);
          match(CPP14Parser::Less);
          setState(1901);
          templateparameterList();
          setState(1902);
          match(CPP14Parser::Greater);
        }
        setState(1906);
        match(CPP14Parser::Class);
        break;
      }

      case CPP14Parser::Typename_: {
        setState(1907);
        match(CPP14Parser::Typename_);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(1921);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 279, _ctx)) {
    case 1: {
      setState(1911);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Ellipsis) {
        setState(1910);
        match(CPP14Parser::Ellipsis);
      }
      setState(1914);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Identifier) {
        setState(1913);
        match(CPP14Parser::Identifier);
      }
      break;
    }

    case 2: {
      setState(1917);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Identifier) {
        setState(1916);
        match(CPP14Parser::Identifier);
      }
      setState(1919);
      match(CPP14Parser::Assign);
      setState(1920);
      theTypeId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleTemplateIdContext ------------------------------------------------------------------

CPP14Parser::SimpleTemplateIdContext::SimpleTemplateIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TemplateNameContext* CPP14Parser::SimpleTemplateIdContext::templateName() {
  return getRuleContext<CPP14Parser::TemplateNameContext>(0);
}

tree::TerminalNode* CPP14Parser::SimpleTemplateIdContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

tree::TerminalNode* CPP14Parser::SimpleTemplateIdContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

CPP14Parser::TemplateArgumentListContext* CPP14Parser::SimpleTemplateIdContext::templateArgumentList() {
  return getRuleContext<CPP14Parser::TemplateArgumentListContext>(0);
}


size_t CPP14Parser::SimpleTemplateIdContext::getRuleIndex() const {
  return CPP14Parser::RuleSimpleTemplateId;
}


std::any CPP14Parser::SimpleTemplateIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitSimpleTemplateId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::simpleTemplateId() {
  SimpleTemplateIdContext *_localctx = _tracker.createInstance<SimpleTemplateIdContext>(_ctx, getState());
  enterRule(_localctx, 342, CPP14Parser::RuleSimpleTemplateId);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1923);
    templateName();
    setState(1924);
    match(CPP14Parser::Less);
    setState(1926);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 8364979472930990334) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & 4719772474384268307) != 0 || _la == CPP14Parser::Identifier) {
      setState(1925);
      templateArgumentList();
    }
    setState(1928);
    match(CPP14Parser::Greater);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateIdContext ------------------------------------------------------------------

CPP14Parser::TemplateIdContext::TemplateIdContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TemplateIdContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

tree::TerminalNode* CPP14Parser::TemplateIdContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

tree::TerminalNode* CPP14Parser::TemplateIdContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

CPP14Parser::OperatorFunctionIdContext* CPP14Parser::TemplateIdContext::operatorFunctionId() {
  return getRuleContext<CPP14Parser::OperatorFunctionIdContext>(0);
}

CPP14Parser::LiteralOperatorIdContext* CPP14Parser::TemplateIdContext::literalOperatorId() {
  return getRuleContext<CPP14Parser::LiteralOperatorIdContext>(0);
}

CPP14Parser::TemplateArgumentListContext* CPP14Parser::TemplateIdContext::templateArgumentList() {
  return getRuleContext<CPP14Parser::TemplateArgumentListContext>(0);
}


size_t CPP14Parser::TemplateIdContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateId;
}


std::any CPP14Parser::TemplateIdContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateId(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateIdContext* CPP14Parser::templateId() {
  TemplateIdContext *_localctx = _tracker.createInstance<TemplateIdContext>(_ctx, getState());
  enterRule(_localctx, 344, CPP14Parser::RuleTemplateId);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1941);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(1930);
        simpleTemplateId();
        break;
      }

      case CPP14Parser::Operator: {
        enterOuterAlt(_localctx, 2);
        setState(1933);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx)) {
        case 1: {
          setState(1931);
          operatorFunctionId();
          break;
        }

        case 2: {
          setState(1932);
          literalOperatorId();
          break;
        }

        default:
          break;
        }
        setState(1935);
        match(CPP14Parser::Less);
        setState(1937);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 8364979472930990334) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 65)) & 4719772474384268307) != 0 || _la == CPP14Parser::Identifier) {
          setState(1936);
          templateArgumentList();
        }
        setState(1939);
        match(CPP14Parser::Greater);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateNameContext ------------------------------------------------------------------

CPP14Parser::TemplateNameContext::TemplateNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TemplateNameContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}


size_t CPP14Parser::TemplateNameContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateName;
}


std::any CPP14Parser::TemplateNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateName(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateNameContext* CPP14Parser::templateName() {
  TemplateNameContext *_localctx = _tracker.createInstance<TemplateNameContext>(_ctx, getState());
  enterRule(_localctx, 346, CPP14Parser::RuleTemplateName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1943);
    match(CPP14Parser::Identifier);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateArgumentListContext ------------------------------------------------------------------

CPP14Parser::TemplateArgumentListContext::TemplateArgumentListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::TemplateArgumentContext *> CPP14Parser::TemplateArgumentListContext::templateArgument() {
  return getRuleContexts<CPP14Parser::TemplateArgumentContext>();
}

CPP14Parser::TemplateArgumentContext* CPP14Parser::TemplateArgumentListContext::templateArgument(size_t i) {
  return getRuleContext<CPP14Parser::TemplateArgumentContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TemplateArgumentListContext::Ellipsis() {
  return getTokens(CPP14Parser::Ellipsis);
}

tree::TerminalNode* CPP14Parser::TemplateArgumentListContext::Ellipsis(size_t i) {
  return getToken(CPP14Parser::Ellipsis, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TemplateArgumentListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::TemplateArgumentListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::TemplateArgumentListContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateArgumentList;
}


std::any CPP14Parser::TemplateArgumentListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateArgumentList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateArgumentListContext* CPP14Parser::templateArgumentList() {
  TemplateArgumentListContext *_localctx = _tracker.createInstance<TemplateArgumentListContext>(_ctx, getState());
  enterRule(_localctx, 348, CPP14Parser::RuleTemplateArgumentList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1945);
    templateArgument();
    setState(1947);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(1946);
      match(CPP14Parser::Ellipsis);
    }
    setState(1956);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(1949);
      match(CPP14Parser::Comma);
      setState(1950);
      templateArgument();
      setState(1952);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Ellipsis) {
        setState(1951);
        match(CPP14Parser::Ellipsis);
      }
      setState(1958);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemplateArgumentContext ------------------------------------------------------------------

CPP14Parser::TemplateArgumentContext::TemplateArgumentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TheTypeIdContext* CPP14Parser::TemplateArgumentContext::theTypeId() {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::TemplateArgumentContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

CPP14Parser::IdExpressionContext* CPP14Parser::TemplateArgumentContext::idExpression() {
  return getRuleContext<CPP14Parser::IdExpressionContext>(0);
}


size_t CPP14Parser::TemplateArgumentContext::getRuleIndex() const {
  return CPP14Parser::RuleTemplateArgument;
}


std::any CPP14Parser::TemplateArgumentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTemplateArgument(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TemplateArgumentContext* CPP14Parser::templateArgument() {
  TemplateArgumentContext *_localctx = _tracker.createInstance<TemplateArgumentContext>(_ctx, getState());
  enterRule(_localctx, 350, CPP14Parser::RuleTemplateArgument);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1962);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 287, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1959);
      theTypeId();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1960);
      constantExpression();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1961);
      idExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeNameSpecifierContext ------------------------------------------------------------------

CPP14Parser::TypeNameSpecifierContext::TypeNameSpecifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Typename_() {
  return getToken(CPP14Parser::Typename_, 0);
}

CPP14Parser::NestedNameSpecifierContext* CPP14Parser::TypeNameSpecifierContext::nestedNameSpecifier() {
  return getRuleContext<CPP14Parser::NestedNameSpecifierContext>(0);
}

tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Identifier() {
  return getToken(CPP14Parser::Identifier, 0);
}

CPP14Parser::SimpleTemplateIdContext* CPP14Parser::TypeNameSpecifierContext::simpleTemplateId() {
  return getRuleContext<CPP14Parser::SimpleTemplateIdContext>(0);
}

tree::TerminalNode* CPP14Parser::TypeNameSpecifierContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}


size_t CPP14Parser::TypeNameSpecifierContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeNameSpecifier;
}


std::any CPP14Parser::TypeNameSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeNameSpecifier(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeNameSpecifierContext* CPP14Parser::typeNameSpecifier() {
  TypeNameSpecifierContext *_localctx = _tracker.createInstance<TypeNameSpecifierContext>(_ctx, getState());
  enterRule(_localctx, 352, CPP14Parser::RuleTypeNameSpecifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1964);
    match(CPP14Parser::Typename_);
    setState(1965);
    nestedNameSpecifier(0);
    setState(1971);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _ctx)) {
    case 1: {
      setState(1966);
      match(CPP14Parser::Identifier);
      break;
    }

    case 2: {
      setState(1968);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Template) {
        setState(1967);
        match(CPP14Parser::Template);
      }
      setState(1970);
      simpleTemplateId();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplicitInstantiationContext ------------------------------------------------------------------

CPP14Parser::ExplicitInstantiationContext::ExplicitInstantiationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ExplicitInstantiationContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

CPP14Parser::DeclarationContext* CPP14Parser::ExplicitInstantiationContext::declaration() {
  return getRuleContext<CPP14Parser::DeclarationContext>(0);
}

tree::TerminalNode* CPP14Parser::ExplicitInstantiationContext::Extern() {
  return getToken(CPP14Parser::Extern, 0);
}


size_t CPP14Parser::ExplicitInstantiationContext::getRuleIndex() const {
  return CPP14Parser::RuleExplicitInstantiation;
}


std::any CPP14Parser::ExplicitInstantiationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExplicitInstantiation(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExplicitInstantiationContext* CPP14Parser::explicitInstantiation() {
  ExplicitInstantiationContext *_localctx = _tracker.createInstance<ExplicitInstantiationContext>(_ctx, getState());
  enterRule(_localctx, 354, CPP14Parser::RuleExplicitInstantiation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1974);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Extern) {
      setState(1973);
      match(CPP14Parser::Extern);
    }
    setState(1976);
    match(CPP14Parser::Template);
    setState(1977);
    declaration();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplicitSpecializationContext ------------------------------------------------------------------

CPP14Parser::ExplicitSpecializationContext::ExplicitSpecializationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Template() {
  return getToken(CPP14Parser::Template, 0);
}

tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Less() {
  return getToken(CPP14Parser::Less, 0);
}

tree::TerminalNode* CPP14Parser::ExplicitSpecializationContext::Greater() {
  return getToken(CPP14Parser::Greater, 0);
}

CPP14Parser::DeclarationContext* CPP14Parser::ExplicitSpecializationContext::declaration() {
  return getRuleContext<CPP14Parser::DeclarationContext>(0);
}


size_t CPP14Parser::ExplicitSpecializationContext::getRuleIndex() const {
  return CPP14Parser::RuleExplicitSpecialization;
}


std::any CPP14Parser::ExplicitSpecializationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExplicitSpecialization(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExplicitSpecializationContext* CPP14Parser::explicitSpecialization() {
  ExplicitSpecializationContext *_localctx = _tracker.createInstance<ExplicitSpecializationContext>(_ctx, getState());
  enterRule(_localctx, 356, CPP14Parser::RuleExplicitSpecialization);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1979);
    match(CPP14Parser::Template);
    setState(1980);
    match(CPP14Parser::Less);
    setState(1981);
    match(CPP14Parser::Greater);
    setState(1982);
    declaration();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TryBlockContext ------------------------------------------------------------------

CPP14Parser::TryBlockContext::TryBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TryBlockContext::Try() {
  return getToken(CPP14Parser::Try, 0);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::TryBlockContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}

CPP14Parser::HandlerSeqContext* CPP14Parser::TryBlockContext::handlerSeq() {
  return getRuleContext<CPP14Parser::HandlerSeqContext>(0);
}


size_t CPP14Parser::TryBlockContext::getRuleIndex() const {
  return CPP14Parser::RuleTryBlock;
}


std::any CPP14Parser::TryBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTryBlock(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TryBlockContext* CPP14Parser::tryBlock() {
  TryBlockContext *_localctx = _tracker.createInstance<TryBlockContext>(_ctx, getState());
  enterRule(_localctx, 358, CPP14Parser::RuleTryBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1984);
    match(CPP14Parser::Try);
    setState(1985);
    compoundStatement();
    setState(1986);
    handlerSeq();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionTryBlockContext ------------------------------------------------------------------

CPP14Parser::FunctionTryBlockContext::FunctionTryBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::FunctionTryBlockContext::Try() {
  return getToken(CPP14Parser::Try, 0);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::FunctionTryBlockContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}

CPP14Parser::HandlerSeqContext* CPP14Parser::FunctionTryBlockContext::handlerSeq() {
  return getRuleContext<CPP14Parser::HandlerSeqContext>(0);
}

CPP14Parser::ConstructorInitializerContext* CPP14Parser::FunctionTryBlockContext::constructorInitializer() {
  return getRuleContext<CPP14Parser::ConstructorInitializerContext>(0);
}


size_t CPP14Parser::FunctionTryBlockContext::getRuleIndex() const {
  return CPP14Parser::RuleFunctionTryBlock;
}


std::any CPP14Parser::FunctionTryBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitFunctionTryBlock(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::FunctionTryBlockContext* CPP14Parser::functionTryBlock() {
  FunctionTryBlockContext *_localctx = _tracker.createInstance<FunctionTryBlockContext>(_ctx, getState());
  enterRule(_localctx, 360, CPP14Parser::RuleFunctionTryBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1988);
    match(CPP14Parser::Try);
    setState(1990);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Colon) {
      setState(1989);
      constructorInitializer();
    }
    setState(1992);
    compoundStatement();
    setState(1993);
    handlerSeq();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerSeqContext ------------------------------------------------------------------

CPP14Parser::HandlerSeqContext::HandlerSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::HandlerContext *> CPP14Parser::HandlerSeqContext::handler() {
  return getRuleContexts<CPP14Parser::HandlerContext>();
}

CPP14Parser::HandlerContext* CPP14Parser::HandlerSeqContext::handler(size_t i) {
  return getRuleContext<CPP14Parser::HandlerContext>(i);
}


size_t CPP14Parser::HandlerSeqContext::getRuleIndex() const {
  return CPP14Parser::RuleHandlerSeq;
}


std::any CPP14Parser::HandlerSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitHandlerSeq(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::HandlerSeqContext* CPP14Parser::handlerSeq() {
  HandlerSeqContext *_localctx = _tracker.createInstance<HandlerSeqContext>(_ctx, getState());
  enterRule(_localctx, 362, CPP14Parser::RuleHandlerSeq);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1996); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(1995);
      handler();
      setState(1998); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == CPP14Parser::Catch);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerContext ------------------------------------------------------------------

CPP14Parser::HandlerContext::HandlerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::HandlerContext::Catch() {
  return getToken(CPP14Parser::Catch, 0);
}

tree::TerminalNode* CPP14Parser::HandlerContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ExceptionDeclarationContext* CPP14Parser::HandlerContext::exceptionDeclaration() {
  return getRuleContext<CPP14Parser::ExceptionDeclarationContext>(0);
}

tree::TerminalNode* CPP14Parser::HandlerContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::CompoundStatementContext* CPP14Parser::HandlerContext::compoundStatement() {
  return getRuleContext<CPP14Parser::CompoundStatementContext>(0);
}


size_t CPP14Parser::HandlerContext::getRuleIndex() const {
  return CPP14Parser::RuleHandler;
}


std::any CPP14Parser::HandlerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitHandler(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::HandlerContext* CPP14Parser::handler() {
  HandlerContext *_localctx = _tracker.createInstance<HandlerContext>(_ctx, getState());
  enterRule(_localctx, 364, CPP14Parser::RuleHandler);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2000);
    match(CPP14Parser::Catch);
    setState(2001);
    match(CPP14Parser::LeftParen);
    setState(2002);
    exceptionDeclaration();
    setState(2003);
    match(CPP14Parser::RightParen);
    setState(2004);
    compoundStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExceptionDeclarationContext ------------------------------------------------------------------

CPP14Parser::ExceptionDeclarationContext::ExceptionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::TypeSpecifierSeqContext* CPP14Parser::ExceptionDeclarationContext::typeSpecifierSeq() {
  return getRuleContext<CPP14Parser::TypeSpecifierSeqContext>(0);
}

CPP14Parser::AttributeSpecifierSeqContext* CPP14Parser::ExceptionDeclarationContext::attributeSpecifierSeq() {
  return getRuleContext<CPP14Parser::AttributeSpecifierSeqContext>(0);
}

CPP14Parser::DeclaratorContext* CPP14Parser::ExceptionDeclarationContext::declarator() {
  return getRuleContext<CPP14Parser::DeclaratorContext>(0);
}

CPP14Parser::AbstractDeclaratorContext* CPP14Parser::ExceptionDeclarationContext::abstractDeclarator() {
  return getRuleContext<CPP14Parser::AbstractDeclaratorContext>(0);
}

tree::TerminalNode* CPP14Parser::ExceptionDeclarationContext::Ellipsis() {
  return getToken(CPP14Parser::Ellipsis, 0);
}


size_t CPP14Parser::ExceptionDeclarationContext::getRuleIndex() const {
  return CPP14Parser::RuleExceptionDeclaration;
}


std::any CPP14Parser::ExceptionDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExceptionDeclaration(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExceptionDeclarationContext* CPP14Parser::exceptionDeclaration() {
  ExceptionDeclarationContext *_localctx = _tracker.createInstance<ExceptionDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 366, CPP14Parser::RuleExceptionDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2015);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Alignas:
      case CPP14Parser::Auto:
      case CPP14Parser::Bool:
      case CPP14Parser::Char:
      case CPP14Parser::Char16:
      case CPP14Parser::Char32:
      case CPP14Parser::Class:
      case CPP14Parser::Const:
      case CPP14Parser::Decltype:
      case CPP14Parser::Double:
      case CPP14Parser::Enum:
      case CPP14Parser::Float:
      case CPP14Parser::Int:
      case CPP14Parser::Long:
      case CPP14Parser::Short:
      case CPP14Parser::Signed:
      case CPP14Parser::Struct:
      case CPP14Parser::Typename_:
      case CPP14Parser::Union:
      case CPP14Parser::Unsigned:
      case CPP14Parser::Void:
      case CPP14Parser::Volatile:
      case CPP14Parser::Wchar:
      case CPP14Parser::LeftBracket:
      case CPP14Parser::Doublecolon:
      case CPP14Parser::Identifier: {
        enterOuterAlt(_localctx, 1);
        setState(2007);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CPP14Parser::Alignas || _la == CPP14Parser::LeftBracket) {
          setState(2006);
          attributeSpecifierSeq();
        }
        setState(2009);
        typeSpecifierSeq();
        setState(2012);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx)) {
        case 1: {
          setState(2010);
          declarator();
          break;
        }

        case 2: {
          setState(2011);
          abstractDeclarator();
          break;
        }

        default:
          break;
        }
        break;
      }

      case CPP14Parser::Ellipsis: {
        enterOuterAlt(_localctx, 2);
        setState(2014);
        match(CPP14Parser::Ellipsis);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ThrowExpressionContext ------------------------------------------------------------------

CPP14Parser::ThrowExpressionContext::ThrowExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::ThrowExpressionContext::Throw() {
  return getToken(CPP14Parser::Throw, 0);
}

CPP14Parser::AssignmentExpressionContext* CPP14Parser::ThrowExpressionContext::assignmentExpression() {
  return getRuleContext<CPP14Parser::AssignmentExpressionContext>(0);
}


size_t CPP14Parser::ThrowExpressionContext::getRuleIndex() const {
  return CPP14Parser::RuleThrowExpression;
}


std::any CPP14Parser::ThrowExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitThrowExpression(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ThrowExpressionContext* CPP14Parser::throwExpression() {
  ThrowExpressionContext *_localctx = _tracker.createInstance<ThrowExpressionContext>(_ctx, getState());
  enterRule(_localctx, 368, CPP14Parser::RuleThrowExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2017);
    match(CPP14Parser::Throw);
    setState(2019);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 8364979464334764286) != 0 || (((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & 4719772474384133201) != 0 || _la == CPP14Parser::Identifier) {
      setState(2018);
      assignmentExpression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExceptionSpecificationContext ------------------------------------------------------------------

CPP14Parser::ExceptionSpecificationContext::ExceptionSpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CPP14Parser::DynamicExceptionSpecificationContext* CPP14Parser::ExceptionSpecificationContext::dynamicExceptionSpecification() {
  return getRuleContext<CPP14Parser::DynamicExceptionSpecificationContext>(0);
}

CPP14Parser::NoeExceptSpecificationContext* CPP14Parser::ExceptionSpecificationContext::noeExceptSpecification() {
  return getRuleContext<CPP14Parser::NoeExceptSpecificationContext>(0);
}


size_t CPP14Parser::ExceptionSpecificationContext::getRuleIndex() const {
  return CPP14Parser::RuleExceptionSpecification;
}


std::any CPP14Parser::ExceptionSpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitExceptionSpecification(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::ExceptionSpecificationContext* CPP14Parser::exceptionSpecification() {
  ExceptionSpecificationContext *_localctx = _tracker.createInstance<ExceptionSpecificationContext>(_ctx, getState());
  enterRule(_localctx, 370, CPP14Parser::RuleExceptionSpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2023);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CPP14Parser::Throw: {
        enterOuterAlt(_localctx, 1);
        setState(2021);
        dynamicExceptionSpecification();
        break;
      }

      case CPP14Parser::Noexcept: {
        enterOuterAlt(_localctx, 2);
        setState(2022);
        noeExceptSpecification();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DynamicExceptionSpecificationContext ------------------------------------------------------------------

CPP14Parser::DynamicExceptionSpecificationContext::DynamicExceptionSpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::Throw() {
  return getToken(CPP14Parser::Throw, 0);
}

tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::DynamicExceptionSpecificationContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}

CPP14Parser::TypeIdListContext* CPP14Parser::DynamicExceptionSpecificationContext::typeIdList() {
  return getRuleContext<CPP14Parser::TypeIdListContext>(0);
}


size_t CPP14Parser::DynamicExceptionSpecificationContext::getRuleIndex() const {
  return CPP14Parser::RuleDynamicExceptionSpecification;
}


std::any CPP14Parser::DynamicExceptionSpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitDynamicExceptionSpecification(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::DynamicExceptionSpecificationContext* CPP14Parser::dynamicExceptionSpecification() {
  DynamicExceptionSpecificationContext *_localctx = _tracker.createInstance<DynamicExceptionSpecificationContext>(_ctx, getState());
  enterRule(_localctx, 372, CPP14Parser::RuleDynamicExceptionSpecification);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2025);
    match(CPP14Parser::Throw);
    setState(2026);
    match(CPP14Parser::LeftParen);
    setState(2028);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 13) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 13)) & -9213942612181769245) != 0 || (((_la - 77) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 77)) & 37154696925806707) != 0) {
      setState(2027);
      typeIdList();
    }
    setState(2030);
    match(CPP14Parser::RightParen);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeIdListContext ------------------------------------------------------------------

CPP14Parser::TypeIdListContext::TypeIdListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CPP14Parser::TheTypeIdContext *> CPP14Parser::TypeIdListContext::theTypeId() {
  return getRuleContexts<CPP14Parser::TheTypeIdContext>();
}

CPP14Parser::TheTypeIdContext* CPP14Parser::TypeIdListContext::theTypeId(size_t i) {
  return getRuleContext<CPP14Parser::TheTypeIdContext>(i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TypeIdListContext::Ellipsis() {
  return getTokens(CPP14Parser::Ellipsis);
}

tree::TerminalNode* CPP14Parser::TypeIdListContext::Ellipsis(size_t i) {
  return getToken(CPP14Parser::Ellipsis, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TypeIdListContext::Comma() {
  return getTokens(CPP14Parser::Comma);
}

tree::TerminalNode* CPP14Parser::TypeIdListContext::Comma(size_t i) {
  return getToken(CPP14Parser::Comma, i);
}


size_t CPP14Parser::TypeIdListContext::getRuleIndex() const {
  return CPP14Parser::RuleTypeIdList;
}


std::any CPP14Parser::TypeIdListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTypeIdList(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TypeIdListContext* CPP14Parser::typeIdList() {
  TypeIdListContext *_localctx = _tracker.createInstance<TypeIdListContext>(_ctx, getState());
  enterRule(_localctx, 374, CPP14Parser::RuleTypeIdList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2032);
    theTypeId();
    setState(2034);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CPP14Parser::Ellipsis) {
      setState(2033);
      match(CPP14Parser::Ellipsis);
    }
    setState(2043);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CPP14Parser::Comma) {
      setState(2036);
      match(CPP14Parser::Comma);
      setState(2037);
      theTypeId();
      setState(2039);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CPP14Parser::Ellipsis) {
        setState(2038);
        match(CPP14Parser::Ellipsis);
      }
      setState(2045);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoeExceptSpecificationContext ------------------------------------------------------------------

CPP14Parser::NoeExceptSpecificationContext::NoeExceptSpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::Noexcept() {
  return getToken(CPP14Parser::Noexcept, 0);
}

tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

CPP14Parser::ConstantExpressionContext* CPP14Parser::NoeExceptSpecificationContext::constantExpression() {
  return getRuleContext<CPP14Parser::ConstantExpressionContext>(0);
}

tree::TerminalNode* CPP14Parser::NoeExceptSpecificationContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::NoeExceptSpecificationContext::getRuleIndex() const {
  return CPP14Parser::RuleNoeExceptSpecification;
}


std::any CPP14Parser::NoeExceptSpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitNoeExceptSpecification(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::NoeExceptSpecificationContext* CPP14Parser::noeExceptSpecification() {
  NoeExceptSpecificationContext *_localctx = _tracker.createInstance<NoeExceptSpecificationContext>(_ctx, getState());
  enterRule(_localctx, 376, CPP14Parser::RuleNoeExceptSpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2052);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 302, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2046);
      match(CPP14Parser::Noexcept);
      setState(2047);
      match(CPP14Parser::LeftParen);
      setState(2048);
      constantExpression();
      setState(2049);
      match(CPP14Parser::RightParen);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2051);
      match(CPP14Parser::Noexcept);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TheOperatorContext ------------------------------------------------------------------

CPP14Parser::TheOperatorContext::TheOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::New() {
  return getToken(CPP14Parser::New, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftBracket() {
  return getToken(CPP14Parser::LeftBracket, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::RightBracket() {
  return getToken(CPP14Parser::RightBracket, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Delete() {
  return getToken(CPP14Parser::Delete, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Plus() {
  return getToken(CPP14Parser::Plus, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Minus() {
  return getToken(CPP14Parser::Minus, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Star() {
  return getToken(CPP14Parser::Star, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Div() {
  return getToken(CPP14Parser::Div, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Mod() {
  return getToken(CPP14Parser::Mod, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Caret() {
  return getToken(CPP14Parser::Caret, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::And() {
  return getToken(CPP14Parser::And, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Or() {
  return getToken(CPP14Parser::Or, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Tilde() {
  return getToken(CPP14Parser::Tilde, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Not() {
  return getToken(CPP14Parser::Not, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Assign() {
  return getToken(CPP14Parser::Assign, 0);
}

std::vector<tree::TerminalNode *> CPP14Parser::TheOperatorContext::Greater() {
  return getTokens(CPP14Parser::Greater);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Greater(size_t i) {
  return getToken(CPP14Parser::Greater, i);
}

std::vector<tree::TerminalNode *> CPP14Parser::TheOperatorContext::Less() {
  return getTokens(CPP14Parser::Less);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Less(size_t i) {
  return getToken(CPP14Parser::Less, i);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::GreaterEqual() {
  return getToken(CPP14Parser::GreaterEqual, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::PlusAssign() {
  return getToken(CPP14Parser::PlusAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::MinusAssign() {
  return getToken(CPP14Parser::MinusAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::StarAssign() {
  return getToken(CPP14Parser::StarAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::ModAssign() {
  return getToken(CPP14Parser::ModAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::XorAssign() {
  return getToken(CPP14Parser::XorAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::AndAssign() {
  return getToken(CPP14Parser::AndAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::OrAssign() {
  return getToken(CPP14Parser::OrAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::RightShiftAssign() {
  return getToken(CPP14Parser::RightShiftAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftShiftAssign() {
  return getToken(CPP14Parser::LeftShiftAssign, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Equal() {
  return getToken(CPP14Parser::Equal, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::NotEqual() {
  return getToken(CPP14Parser::NotEqual, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::LessEqual() {
  return getToken(CPP14Parser::LessEqual, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::AndAnd() {
  return getToken(CPP14Parser::AndAnd, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::OrOr() {
  return getToken(CPP14Parser::OrOr, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::PlusPlus() {
  return getToken(CPP14Parser::PlusPlus, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::MinusMinus() {
  return getToken(CPP14Parser::MinusMinus, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Comma() {
  return getToken(CPP14Parser::Comma, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::ArrowStar() {
  return getToken(CPP14Parser::ArrowStar, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::Arrow() {
  return getToken(CPP14Parser::Arrow, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::LeftParen() {
  return getToken(CPP14Parser::LeftParen, 0);
}

tree::TerminalNode* CPP14Parser::TheOperatorContext::RightParen() {
  return getToken(CPP14Parser::RightParen, 0);
}


size_t CPP14Parser::TheOperatorContext::getRuleIndex() const {
  return CPP14Parser::RuleTheOperator;
}


std::any CPP14Parser::TheOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitTheOperator(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::TheOperatorContext* CPP14Parser::theOperator() {
  TheOperatorContext *_localctx = _tracker.createInstance<TheOperatorContext>(_ctx, getState());
  enterRule(_localctx, 378, CPP14Parser::RuleTheOperator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2105);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 305, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2054);
      match(CPP14Parser::New);
      setState(2057);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 303, _ctx)) {
      case 1: {
        setState(2055);
        match(CPP14Parser::LeftBracket);
        setState(2056);
        match(CPP14Parser::RightBracket);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2059);
      match(CPP14Parser::Delete);
      setState(2062);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 304, _ctx)) {
      case 1: {
        setState(2060);
        match(CPP14Parser::LeftBracket);
        setState(2061);
        match(CPP14Parser::RightBracket);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2064);
      match(CPP14Parser::Plus);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2065);
      match(CPP14Parser::Minus);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2066);
      match(CPP14Parser::Star);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2067);
      match(CPP14Parser::Div);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2068);
      match(CPP14Parser::Mod);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2069);
      match(CPP14Parser::Caret);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2070);
      match(CPP14Parser::And);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(2071);
      match(CPP14Parser::Or);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(2072);
      match(CPP14Parser::Tilde);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(2073);
      match(CPP14Parser::Not);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(2074);
      match(CPP14Parser::Assign);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(2075);
      match(CPP14Parser::Greater);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(2076);
      match(CPP14Parser::Less);
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(2077);
      match(CPP14Parser::GreaterEqual);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(2078);
      match(CPP14Parser::PlusAssign);
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(2079);
      match(CPP14Parser::MinusAssign);
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(2080);
      match(CPP14Parser::StarAssign);
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(2081);
      match(CPP14Parser::ModAssign);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(2082);
      match(CPP14Parser::XorAssign);
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(2083);
      match(CPP14Parser::AndAssign);
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(2084);
      match(CPP14Parser::OrAssign);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(2085);
      match(CPP14Parser::Less);
      setState(2086);
      match(CPP14Parser::Less);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(2087);
      match(CPP14Parser::Greater);
      setState(2088);
      match(CPP14Parser::Greater);
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(2089);
      match(CPP14Parser::RightShiftAssign);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(2090);
      match(CPP14Parser::LeftShiftAssign);
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(2091);
      match(CPP14Parser::Equal);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(2092);
      match(CPP14Parser::NotEqual);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(2093);
      match(CPP14Parser::LessEqual);
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(2094);
      match(CPP14Parser::AndAnd);
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(2095);
      match(CPP14Parser::OrOr);
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(2096);
      match(CPP14Parser::PlusPlus);
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(2097);
      match(CPP14Parser::MinusMinus);
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(2098);
      match(CPP14Parser::Comma);
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(2099);
      match(CPP14Parser::ArrowStar);
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(2100);
      match(CPP14Parser::Arrow);
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(2101);
      match(CPP14Parser::LeftParen);
      setState(2102);
      match(CPP14Parser::RightParen);
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(2103);
      match(CPP14Parser::LeftBracket);
      setState(2104);
      match(CPP14Parser::RightBracket);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LiteralContext ------------------------------------------------------------------

CPP14Parser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CPP14Parser::LiteralContext::IntegerLiteral() {
  return getToken(CPP14Parser::IntegerLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::CharacterLiteral() {
  return getToken(CPP14Parser::CharacterLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::FloatingLiteral() {
  return getToken(CPP14Parser::FloatingLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::StringLiteral() {
  return getToken(CPP14Parser::StringLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::BooleanLiteral() {
  return getToken(CPP14Parser::BooleanLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::PointerLiteral() {
  return getToken(CPP14Parser::PointerLiteral, 0);
}

tree::TerminalNode* CPP14Parser::LiteralContext::UserDefinedLiteral() {
  return getToken(CPP14Parser::UserDefinedLiteral, 0);
}


size_t CPP14Parser::LiteralContext::getRuleIndex() const {
  return CPP14Parser::RuleLiteral;
}


std::any CPP14Parser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<CPP14ParserVisitor*>(visitor))
    return parserVisitor->visitLiteral(this);
  else
    return visitor->visitChildren(this);
}

CPP14Parser::LiteralContext* CPP14Parser::literal() {
  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
  enterRule(_localctx, 380, CPP14Parser::RuleLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2107);
    _la = _input->LA(1);
    if (!(((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 254) != 0)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool CPP14Parser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 5: return nestedNameSpecifierSempred(antlrcpp::downCast<NestedNameSpecifierContext *>(context), predicateIndex);
    case 15: return postfixExpressionSempred(antlrcpp::downCast<PostfixExpressionContext *>(context), predicateIndex);
    case 25: return noPointerNewDeclaratorSempred(antlrcpp::downCast<NoPointerNewDeclaratorContext *>(context), predicateIndex);
    case 115: return noPointerDeclaratorSempred(antlrcpp::downCast<NoPointerDeclaratorContext *>(context), predicateIndex);
    case 126: return noPointerAbstractDeclaratorSempred(antlrcpp::downCast<NoPointerAbstractDeclaratorContext *>(context), predicateIndex);
    case 128: return noPointerAbstractPackDeclaratorSempred(antlrcpp::downCast<NoPointerAbstractPackDeclaratorContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::nestedNameSpecifierSempred(NestedNameSpecifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::postfixExpressionSempred(PostfixExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 1: return precpred(_ctx, 7);
    case 2: return precpred(_ctx, 6);
    case 3: return precpred(_ctx, 4);
    case 4: return precpred(_ctx, 3);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::noPointerNewDeclaratorSempred(NoPointerNewDeclaratorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 5: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::noPointerDeclaratorSempred(NoPointerDeclaratorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 6: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::noPointerAbstractDeclaratorSempred(NoPointerAbstractDeclaratorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 7: return precpred(_ctx, 4);

  default:
    break;
  }
  return true;
}

bool CPP14Parser::noPointerAbstractPackDeclaratorSempred(NoPointerAbstractPackDeclaratorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 8: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

void CPP14Parser::initialize() {
  ::antlr4::internal::call_once(cpp14parserParserOnceFlag, cpp14parserParserInitialize);
}
